actix-extras/guide/src/qs_3_5.md

# Server

## Multi-threading

Http server automatically starts number of http workers, by default
this number is equal to number of logical cpu in the system. This number
could be overriden with `HttpServer::threads()` method.

```rust
# extern crate actix_web;
# extern crate tokio_core;
# use tokio_core::net::TcpStream;
# use std::net::SocketAddr;
use actix_web::*;

fn main() {
    HttpServer::<TcpStream, SocketAddr, _, _>::new(
        || Application::new()
            .resource("/", |r| r.f(|r| httpcodes::HTTPOk)))
        .threads(4); // <- Start 4 threads
}
```

Server create separate application instance for each created worker. Application state
is not shared between threads, to share state `Arc` could be used. Application state
does not need to be `Send` and `Sync` but application factory must be `Send` + `Sync`.

## Keep-Alive

Actix can wait for requesta on a keep-alive connection. *Keep alive*
connection behavior is defined by server settings.

 * `Some(75)` - enable 75 sec *keep alive* timer according request and response settings.
 * `Some(0)` - disable *keep alive*.
 * `None` - Use `SO_KEEPALIVE` socket option.

```rust
# extern crate actix_web;
# extern crate tokio_core;
# use tokio_core::net::TcpStream;
# use std::net::SocketAddr;
use actix_web::*;

fn main() {
    HttpServer::<TcpStream, SocketAddr, _, _>::new(||
        Application::new()
            .resource("/", |r| r.f(|r| httpcodes::HTTPOk)))
        .keep_alive(None); // <- Use `SO_KEEPALIVE` socket option.
}
```

If first option is selected then *keep alive* state
calculated based on response's *connection-type*. By default
`HttpResponse::connection_type` is not defined in that case *keep alive*
defined by request's http version. Keep alive is off for *HTTP/1.0*
and is on for *HTTP/1.1* and "HTTP/2.0".

*Connection type* could be change with `HttpResponseBuilder::connection_type()` method.

```rust
# extern crate actix_web;
# use actix_web::httpcodes::*;
use actix_web::*;

fn index(req: HttpRequest) -> HttpResponse {
    HTTPOk.build()
        .connection_type(headers::ConnectionType::Close) // <- Close connection
        .finish().unwrap()
}
# fn main() {}
```