TCP 并发：从原理到高并发实践

1. 引言

TCP 并发是网络编程中的核心话题。无论是 Web 服务器、消息队列还是游戏网关，底层都离不开 TCP 连接的高效管理。本文从 TCP 并发的基本概念出发，逐步讲解多线程、多进程、事件驱动等常见并发模型，并结合实际场景给出选型建议。

2. TCP 并发的基本概念

TCP 并发，简单来说，就是服务器在同一时刻处理大量 TCP 连接的能力。要理解并发，先要分清两个容易混淆的概念：

并发连接数：当前处于 ESTABLISHED 状态的连接总数，反映系统能同时承载多少客户端。
吞吐量：单位时间内成功传输的数据量，反映系统的实际处理效率。

高并发连接数并不等于高吞吐量。如果大量连接只是保持空闲，系统资源消耗有限；真正考验系统的是大量连接同时活跃读写时的调度能力。

3. 从单线程到多线程

最简单的 TCP 服务器是单线程串行处理：accept 一个连接，处理完再 accept 下一个。这种方式实现简单，但一个慢客户端会阻塞后面所有请求，显然无法满足并发需求。

多线程模型是最直接的改进：每个连接分配一个线程，连接之间互不阻塞。下面是一个 Java 实现的多线程 TCP 服务器示例：

java 复制代码

import java.io.*;
import java.net.*;
public class ThreadedServer {
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket(8080);
while (true) {
Socket socket = server.accept();
new Thread(() -> handle(socket)).start();
}
}
private static void handle(Socket socket) {
    try (BufferedReader in = new BufferedReader(
            new InputStreamReader(socket.getInputStream()));
         PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
        String line;
        while ((line = in.readLine()) != null) {
            out.println("echo: " + line);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}
}

多线程模型虽然直观，但存在明显瓶颈：线程创建和上下文切换开销大，每个线程默认占用约 1MB 栈空间，几万连接就会耗尽内存。因此它更适合连接数较少、请求处理较重的场景。

4. 线程池优化

为了减少线程频繁创建销毁的开销，可以用线程池复用线程。线程池的核心参数包括核心线程数、最大线程数和任务队列长度。

线程池的大小需要根据任务类型调整：

CPU 密集型任务：线程数建议设为 CPU 核心数加一，避免过多线程竞争 CPU。
IO 密集型任务：线程数可以适当调大，因为线程大部分时间在等待 IO。

但线程池并没有解决根本问题：当连接数达到数万甚至数十万时，每个连接即使只占用一个线程，系统也无法承受。此时需要引入事件驱动模型。

5. 事件驱动与 NIO

事件驱动模型的核心思想是：用一个或少数几个线程监听大量连接的事件，当某个连接可读或可写时才去处理它，空闲连接不占用线程。

Java NIO 的 Selector 就是这种模型的典型实现。它通过注册感兴趣的事件，让一个线程同时管理成千上万个连接。下面是一个基于 NIO 的简单示例：

java 复制代码

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
public class NioServer {
public static void main(String[] args) throws IOException {
Selector selector = Selector.open();
ServerSocketChannel server = ServerSocketChannel.open();
server.bind(new InetSocketAddress(8080));
server.configureBlocking(false);
server.register(selector, SelectionKey.OP_ACCEPT);
    while (true) {
        selector.select();
        Iterator&lt;SelectionKey&gt; it = selector.selectedKeys().iterator();
        while (it.hasNext()) {
            SelectionKey key = it.next();
            it.remove();
            if (key.isAcceptable()) {
                SocketChannel client = server.accept();
                client.configureBlocking(false);
                client.register(selector, SelectionKey.OP_READ);
            } else if (key.isReadable()) {
                SocketChannel client = (SocketChannel) key.channel();
                ByteBuffer buf = ByteBuffer.allocate(1024);
                int n = client.read(buf);
                if (n == -1) {
                    client.close();
                } else {
                    buf.flip();
                    client.write(buf);
                }
            }
        }
    }
}
}

NIO 模型解决了 C10K 问题，但代码复杂度明显上升。为了兼顾性能和开发效率，业界出现了 Netty 这样的封装框架，它在 NIO 之上提供了更友好的编程模型。

6. 多进程模型与系统限制

除了多线程，多进程模型也是常见的并发方案。每个连接由一个子进程处理，进程间内存隔离，稳定性更好，但进程创建开销更大，适合对隔离性要求高的场景。

无论采用哪种模型，TCP 并发都受系统资源限制，常见瓶颈包括：

文件描述符限制：每个 TCP 连接占用一个 fd，默认 ulimit 往往只有 1024，需要调大。
端口范围：客户端大量短连接时，源端口可能耗尽，需要调整 net.ipv4.ip_local_port_range。
TCP 内存：每个连接的内核缓冲区都会占用内存，需要关注 net.ipv4.tcp_mem 等参数。

下面是一组常用的 Linux 内核参数调优示例：

bash 复制代码

# 调大文件描述符限制
ulimit -n 100000
扩大本地端口范围
sysctl -w net.ipv4.ip_local_port_range="1024 65535"
开启 TIME_WAIT 复用，减少短连接开销
sysctl -w net.ipv4.tcp_tw_reuse=1
调大 TCP 读写缓冲区
sysctl -w net.core.rmem_max=16777216
sysctl -w net.core.wmem_max=16777216

7. 常见并发模型对比

模型	并发能力	开发复杂度	适用场景
单线程串行	极低	低	教学、简单工具
多线程	中	中	中小规模业务
线程池	中高	中	请求处理较重的服务
事件驱动 NIO	高	高	高并发网关、IM 服务
多进程	中高	中	隔离性要求高的场景

8. 实践建议与总结

在实际项目中，选择 TCP 并发模型需要结合业务特点：

连接数少、逻辑复杂，优先考虑线程池。
连接数多、单个请求轻量，优先考虑事件驱动模型。
对稳定性要求极高，可以结合多进程与事件驱动，例如 Nginx 的 worker 进程模型。

此外，压测是验证并发能力的重要手段。建议从低并发逐步加压，观察 CPU、内存、文件描述符和 TCP 连接状态的变化，找到系统的真实瓶颈。TCP 并发没有银弹，理解底层原理，才能在不同场景下做出合理取舍。