onethreadperconnection

One thread per connection is a server design pattern in which each active network connection is serviced by its own operating system thread. The approach relies on blocking I/O and assigns a dedicated thread to handle all interaction with a single client, from the initial handshake to processing requests and sending responses.

In a typical implementation, a server listens for new connections, accepts them, and immediately spawns a new thread to handle that client. The per-connection thread maintains its own state and blocks on reads and writes, processing incoming data and producing responses until the client disconnects or the session ends.

Advantages of this pattern include simplicity and clear isolation between clients. The code for a single connection tends to be straightforward to write and reason about, and it naturally scales with available CPU cores since threads can run concurrently on separate cores.

Disadvantages center on scalability and resource use. Each thread consumes memory for its stack and kernel resources, which can lead to high memory overhead for large numbers of connections. Context switching between many threads can cause performance variability and increased CPU load. This model is generally unsuitable for servers expected to handle thousands or tens of thousands of concurrent connections.

Alternatives emphasize non-blocking or asynchronous I/O. Event-driven servers multiplex many connections over a small number of threads using mechanisms such as epoll, kqueue, or IOCP, or employ thread pools or coroutine-based approaches. The choice depends on workload characteristics, latency requirements, and resource constraints.