actix-web/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`.

## SSL

There are two `tls` and `alpn` features for ssl server. `tls` feature is for `native-tls`
integration and `alpn` is for `openssl`.

```toml
[dependencies]
actix-web = { git = "https://github.com/actix/actix-web", features=["alpn"] }
```

```rust,ignore
use std::fs::File;
use actix_web::*;

fn main() {
    let mut file = File::open("identity.pfx").unwrap();
    let mut pkcs12 = vec![];
    file.read_to_end(&mut pkcs12).unwrap();
    let pkcs12 = Pkcs12::from_der(&pkcs12).unwrap().parse("12345").unwrap();

    HttpServer::new(
        || Application::new()
            .resource("/index.html", |r| r.f(index)))
        .serve_ssl::<_, ()>("127.0.0.1:8080", pkcs12).unwrap();
}
```

Note on *HTTP/2.0* protocol over tls without prior knowlage, it requires
[tls alpn](https://tools.ietf.org/html/rfc7301). At the moment only
`openssl` has `alpn ` support.

Please check [example](https://github.com/actix/actix-web/tree/master/examples/tls) 
for concrete example.

## 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
        .force_close()                                   // <- Alternative method
        .finish().unwrap()
}
# fn main() {}
```