TCP 服务端比 UDP 多两个调用:listen 和 accept。这两个调用经常被理解成"开始监听"和"建立连接",但连接并不是 accept 建立的——三次握手在 listen 之后由内核自动完成,accept 只是从队列里取一个已经建好的连接。
五个调用各自改了什么
int socket(int domain, int type, int protocol); /* 创建套接字 */
int bind(int sockfd, const struct sockaddr *addr, socklen_t len); /* 绑定本地地址 */
int listen(int sockfd, int backlog); /* 转入监听 */
int accept(int sockfd, struct sockaddr *addr, socklen_t *len); /* 取出一个连接 */
int connect(int sockfd, const struct sockaddr *addr, socklen_t len); /* 发起连接 */TCP 的 socket 参数是 AF_INET、SOCK_STREAM、0。它返回的 fd 和 UDP 一样是文件描述符,但此时还只是个"套接字壳子",既没有地址也没有连接。
bind 的填法和 UDP 完全一致:清零结构体、sin_family = AF_INET、sin_port = htons(port)、sin_addr.s_addr = htonl(INADDR_ANY)、第三个参数 sizeof(local)。INADDR_ANY 是全零,htonl 转不转结果都一样,写 htonl 只是让"这个值要进网络"的意图更明确。服务端必须 bind 一个固定端口,否则内核每次启动分配的端口都不同,客户端没法找;客户端不必 bind,connect 时会由内核选源地址和临时端口——显式 bind 固定端口反而会让同一台机器上第二个客户端起不来。
listen 做了两件事:把套接字从"可 bind 的普通套接字"变成监听套接字,并让内核开始对这个地址端口上的 SYN 做应答。它不建立连接,只决定"这个门口排队排多长";成功返回 0,失败返回 -1。
accept 从已完成连接的队列里取出一个,返回一个新的 fd。队列为空时它就阻塞,直到有连接完成握手;这也是顺序服务端"卡住"的直接原因。失败时返回 -1,典型原因是进程被信号打断(EINTR)或监听 fd 已经关掉。监听 fd 只负责收连接,新 fd 才是这条连接的读写句柄;一个服务端可以有很多个新 fd,但监听 fd 始终只有一个。addr 是输出参数,返回对端地址;不关心就传 NULL。addrlen 又是 value-result:传入缓冲区大小,传出实际长度。
connect 的参数形式与 bind 一样,区别只在语义:bind 给的是自己的地址,connect 给的是对方的地址。它阻塞到握手完成或失败,成功返回 0,失败返回 -1,常见错误码是 ECONNREFUSED(端口没人监听)和 ETIMEDOUT(SYN 没有回应)。
setsockopt 的第三个参数是选项名,不是位掩码
课件的服务端写了这样一行:
setsockopt(_listensock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));这行设不上 SO_REUSEADDR。setsockopt 的第三个参数是单个 optname,不是可以按位或的标志集合。Linux 上 SO_REUSEADDR 的值是 2,SO_REUSEPORT 是 15,2 | 15 还是 15,于是最终生效的只有 SO_REUSEPORT。
后果很具体:SO_REUSEADDR 的作用是允许在端口处于 TIME_WAIT 时重新 bind,这正是重启服务端最需要的行为;只设上 SO_REUSEPORT 时,旧连接还留在 TIME_WAIT,重启仍可能拿到 EADDRINUSE(errno 98)。正确写法是两次调用:
int opt = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
setsockopt(listenfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)); /* 需要时再加 */SO_REUSEPORT 是另一件事:允许多个套接字绑同一个端口,由内核在它们之间分流,通常用于多进程负载均衡。不需要多进程共享端口时,别顺手加上。
三次握手对应到哪几个调用
| 时刻 | 客户端状态 | 服务端状态 |
|---|---|---|
socket() 之后 | CLOSED | CLOSED |
bind() + listen() | — | LISTEN |
connect() 发出 SYN | SYN_SENT | 收到 SYN,回 SYN+ACK,进入 SYN_RECV |
| 客户端收到 SYN+ACK,回 ACK | ESTABLISHED,connect 返回 | 收到 ACK,进入 ESTABLISHED,连接被放进已完成队列 |
accept() | — | 从已完成队列取出,返回新 fd |
这张表里最容易被忽略的是最后两行的时间差。connect 返回成功时,服务端可能一行 accept 都还没执行,连接照样已经建立并排在队列里。客户端的 send 可以把数据发出去,这些数据躺在这条连接的接收缓冲区里,等 accept 取出 fd 之后才读得到。
accept 之前还有一个队列:只收到 SYN、还没完成握手的连接,在 SYN 队列里;三次握手完成、等着被 accept 的连接,在已完成队列(accept queue)里。
课件对 listen 的说明是"最多允许有 backlog 个客户端处于连接等待状态,如果接收到更多的连接请求就忽略,一般设为 5"。这里要拆成两句:
backlog不是"最大连接数"。它只限制已握手完成、还没被 accept 取走的队列长度。已经 accept 的连接不占这个名额,所以一个 backlog 为 5 的服务端可以同时维持几百条连接——只要 accept 循环跟得上。Linux 的listen(2)手册写明,自 2.2 起 backlog 指定的是已完成队列长度;未完成队列的上限由/proc/sys/net/ipv4/tcp_max_syn_backlog控制。- "更多就忽略"也不准确。队列满时,内核对新连接的处理取决于
tcp_abort_on_overflow等设置:默认既不接受也不明确拒绝,客户端通常看到重传后超时,而不是立刻收到一个"拒绝"。
backlog 写 5 在今天偏小,常见服务端用 128 或 512;它的上限受 somaxconn 约束。
一个能跑的回显服务端和客户端
/* tcp_echo_server.c: gcc tcp_echo_server.c -o tcp_echo_server */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define BUF_SIZE 1024
static void service(int fd)
{
char buf[BUF_SIZE];
for (;;) {
ssize_t n = read(fd, buf, sizeof(buf) - 1);
if (n > 0) {
buf[n] = '\0';
printf("client say# %s\n", buf);
if (write(fd, buf, (size_t)n) < 0) {
perror("write");
break;
}
} else if (n == 0) {
printf("client quit\n");
break;
} else {
if (errno == EINTR)
continue;
perror("read");
break;
}
}
}
int main(int argc, char *argv[])
{
if (argc != 2) {
fprintf(stderr, "usage: %s port\n", argv[0]);
return 1;
}
uint16_t port = (uint16_t)strtoul(argv[1], NULL, 10);
signal(SIGPIPE, SIG_IGN);
int listenfd = socket(AF_INET, SOCK_STREAM, 0);
if (listenfd < 0) {
perror("socket");
return 1;
}
int opt = 1;
if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
perror("setsockopt");
close(listenfd);
return 1;
}
struct sockaddr_in local;
memset(&local, 0, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(port);
local.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(listenfd, (struct sockaddr *)&local, sizeof(local)) < 0) {
perror("bind");
close(listenfd);
return 1;
}
if (listen(listenfd, 128) < 0) {
perror("listen");
close(listenfd);
return 1;
}
printf("tcp echo server on port %u\n", (unsigned)port);
for (;;) {
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int fd = accept(listenfd, (struct sockaddr *)&peer, &len);
if (fd < 0) {
if (errno == EINTR)
continue;
perror("accept");
break;
}
char ip[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &peer.sin_addr, ip, sizeof(ip));
printf("accept %s:%u, fd=%d\n",
ip, (unsigned)ntohs(peer.sin_port), fd);
service(fd);
close(fd);
}
close(listenfd);
return 0;
}读返回值的三种情况必须分开处理:n > 0 是数据,n == 0 是对端发了 FIN(TCP 里的"文件结尾"),n < 0 才是错误。EINTR 要重试,其余错误直接放弃这条连接。
客户端:
/* tcp_echo_client.c: gcc tcp_echo_client.c -o tcp_echo_client */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
int main(int argc, char *argv[])
{
if (argc != 3) {
fprintf(stderr, "usage: %s server_ip server_port\n", argv[0]);
return 1;
}
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0) {
perror("socket");
return 1;
}
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons((uint16_t)strtoul(argv[2], NULL, 10));
if (inet_pton(AF_INET, argv[1], &server.sin_addr) != 1) {
fprintf(stderr, "bad ip: %s\n", argv[1]);
close(fd);
return 1;
}
if (connect(fd, (struct sockaddr *)&server, sizeof(server)) < 0) {
perror("connect");
close(fd);
return 1;
}
char line[1024];
while (fgets(line, sizeof(line), stdin) != NULL) {
size_t n = strlen(line);
if (n > 0 && line[n - 1] == '\n')
line[--n] = '\0';
if (n == 0)
continue;
if (write(fd, line, n) < 0) {
perror("write");
break;
}
char buf[1024];
ssize_t m = read(fd, buf, sizeof(buf) - 1);
if (m > 0) {
buf[m] = '\0';
printf("echo# %s\n", buf);
} else if (m == 0) {
printf("server closed\n");
break;
} else {
perror("read");
break;
}
}
close(fd);
return 0;
}客户端 connect 成功后就用同一个 fd 读写,不会再产生新 fd;新 fd 只出现在服务端的 accept 返回值里。
read/write 和 send/recv 在 Linux 上都能用于套接字:read 等价于不带 flags 的 recv,write 等价于不带 flags 的 send。区别在于后两个能带选项——MSG_DONTWAIT 让这一次调用非阻塞,MSG_PEEK 只看数据不从缓冲区取走,MSG_NOSIGNAL 让这一次写入不产生 SIGPIPE。课件两种写法都用了,功能一样;判断 EOF 时也都要看返回值 0。
写方向还有一个容易漏的点:write 和 send 的返回值是实际写入的字节数,可能小于请求长度。内核发送缓冲区快满时,它只收下一部分就返回;非阻塞模式下更常见。小报文通常一次写完,大报文和慢速对端必须循环补齐剩下的部分,不能把"返回了正数"当成"全部发出去了"。
监听 fd 和连接 fd 是两个独立对象,在 ss -tnp 里会同时出现:一行是 LISTEN,本地地址是监听端口;另一行是 ESTABLISHED,本地地址和远端地址构成一个四元组。连接结束只 close 新 fd,监听 fd 要活到进程退出;提前关掉监听 fd,后续客户端 connect 会收到 RST,而不是排队等待。
为什么第二个客户端连上了却不回话
先起服务端,再开两个客户端,第二个客户端敲字后没有任何回显。这不是 listen 的 backlog 太小,也不是第二个连接没建立——它的握手同样完成了,正躺在 accept queue 里。
原因是服务端只有一条执行线:accept 返回后进入 service(fd) 的 for (;;),一直读到第一个客户端关闭;只要那个人不说话也不退出,accept 就永远轮不到第二次调用。第二个客户端的数据已经在内核缓冲区里,但没人去读。
这个现象说明三件事:握手与 accept 是两个阶段;backlog 兜住的是"已完成但没人取"的连接;一个连接一个执行单元,才能同时服务多个客户端。后面的多进程、多线程、线程池都是在补最后一条。
多进程与多线程:一个连接一个执行单元
最直接的并行化是每个连接一个进程。子进程继承父进程的全部 fd,所以必须先把监听 fd 关掉,否则子进程也会拿着它,影响后续资源回收。
/* 需要 <sys/wait.h>、<unistd.h>,与前面的 service() 一起使用 */
static void process_connection(int listenfd, int fd)
{
pid_t id = fork();
if (id < 0) {
perror("fork");
close(fd);
return;
}
if (id == 0) {
close(listenfd);
if (fork() > 0)
_exit(0); /* 中间这一层立刻退出,孙子进程被 init 领养 */
service(fd);
close(fd);
_exit(0);
}
close(fd);
waitpid(id, NULL, 0);
}两次 fork 是为了省掉父进程的 wait。子进程再 fork 出一个孙子进程后自己退出,服务连接的是孙子;孙子成了孤儿,由系统接管,父进程 waitpid 只等那个立刻退出的子进程,不会一直挂着。父进程同时关掉 fd,因为这条连接已经交给孙子,多留一份引用只会让端口晚一点释放。
代价也明显:每个连接一个进程,进程创建的开销和内存占用都不小,几百个连接就撑不住了。
线程版:一个连接一个线程
线程版把 service 挪进线程入口。参数要 heap 分配,因为 pthread_create 的 void * 只能传一个指针,栈上的局部变量在循环下一轮就被覆盖了。
/* 需要 <pthread.h>、<stdlib.h> */
struct thread_data {
int fd;
struct sockaddr_in peer;
};
static void *thread_routine(void *arg)
{
struct thread_data *td = (struct thread_data *)arg;
pthread_detach(pthread_self());
service(td->fd);
close(td->fd);
free(td);
return NULL;
}
static void process_connection_thread(int fd, const struct sockaddr_in *peer)
{
pthread_t tid;
struct thread_data *td = malloc(sizeof(*td));
if (td == NULL) {
close(fd);
return;
}
td->fd = fd;
td->peer = *peer;
int ret = pthread_create(&tid, NULL, thread_routine, td);
if (ret != 0) {
fprintf(stderr, "pthread_create: %d\n", ret);
close(fd);
free(td);
}
}pthread_detach(pthread_self()) 让线程结束后自动回收资源,主线程不需要 join。main 的 accept 循环里把 service(fd); close(fd); 换成 process_connection_thread(fd, &peer); 即可。注意这里不再由主线程 close(fd)——fd 已经属于新线程,主线程关掉会让它读到无效 fd。
线程比进程轻,但"一连接一线程"仍然把线程数绑在连接数上。连接上万时,栈空间和调度开销都成了问题。
线程池与远程命令执行
线程池版本把连接包成一个 std::function<void()> 任务丢进队列:
using func_t = std::function<void()>;
func_t func = std::bind(&TcpServer::Service, this, sockfd, addr);
ThreadPool<func_t>::GetInstance()->Push(func);课件在这行旁边注了"这里不能 auto"。原因是 ThreadPool 的模板参数被写死成 func_t,std::bind 返回的是一个未指定类型的函数对象,用 auto 推出来的类型和 func_t 不是同一个;显式声明成 func_t,bind 的结果才会被转换成 std::function。另外 std::bind 会复制参数,addr 和 sockfd 都被复制进任务对象,任务执行时局部变量早已失效也没关系。
同一个多线程框架加一个命令执行业务,就是课件里的远程命令:
- 业务类持有连接 fd,用
popen(command, "r")起一个子 shell 读命令输出,读完pclose回收子进程; - 只允许白名单里的命令(
ls、pwd、whoami之类),否则等于把 shell 送给网络上的任何人; - 有的命令没有输出(
touch),SendCommand里补一个"done",否则客户端收到 0 字节,会以为服务端没响应。
它同时也埋了后面要处理的问题:服务端只调一次 recv 就把收到的内容当完整命令,客户端两次 send 可能被合并成一次读,一条长命令也可能被拆成两次读。TCP 是字节流,没有报文边界,这就是粘包。命令结果一次 send 发回去、客户端一次 recv 收,同样可能只收到前半段。
对端先关,SIGPIPE 会把进程带走
回显服务端写回数据用的是 write。如果客户端在发送之后立刻关掉,服务端某个时刻的 write 会遇到一个已经收到 RST 的连接,内核给进程发 SIGPIPE。这个信号的默认动作是终止进程——单进程服务端会整个退出,而报错信息一行都没有;多进程版本里只是当前子进程死掉,主进程还活着,所以这个 bug 在多进程版本里更不容易被发现。
处理方式有两种,选一种即可:
signal(SIGPIPE, SIG_IGN); /* 进程级:忽略,write 返回 -1/EPIPE */
write(fd, buf, n); /* 此时按普通错误处理 */
ssize_t m = send(fd, buf, n, MSG_NOSIGNAL); /* 单次调用级:只对这一次 send 生效 */服务端在 main 开头忽略 SIGPIPE,把 write 的 -1 当作"这条连接没了",close 之后继续 accept,是最省事的做法。
关闭本身也有成本。close(fd) 会让这一侧发出 FIN,进入四次挥手;主动关闭的一方最后要停在 TIME_WAIT,等 2MSL(Linux 上约 60 秒)才真正释放这个四元组。这段时间内重新 bind 同一个端口,就会碰上 EADDRINUSE——这也正是前面必须单独设 SO_REUSEADDR 的原因。
两个容易混淆的错误状态:read 返回 0 是对端正常关闭,read 返回 -1 且 errno == ECONNRESET 是对端发了 RST(比如进程被杀、或往已关闭的连接继续写)。前者可以安静地关掉,后者通常意味着对端已经不告而别。
还没有评论 — 第一条由你来留。