【C++高并发服务器WebServer】-12：TCP详解及实现

2025-05-01 01:57:07 0 阅读

本文目录

一、TCP通信流程
二、套接字函数
- 2.1 socket()
- 2.2 bind()
- 2.3 listen()
- 2.4 accept()
- 2.5 connect()
三、demo实现
- 3.1 server端代码
- 3.2 client端代码
四、TCP三次握手
五、TCP滑动窗口
六、TCP四次挥手
七、多进程并发服务器

一、TCP通信流程

先来讲讲服务器端，是被动接受连接的角色，因为是被动的，所以需要先创建一个用于监听的套接字fd。监听有客户端的连接。套接字就是一个文件描述符。

socket创建的fd会有对应的读写缓冲区，然后将监听文件描述符和本地IP+端口绑定（IP+端口就是服务器的地址信息），这一步也就是bind，然后再进行listen。

开始监听之后，就是阻塞等待，当有客户端发起连接，会向监听的fd读缓冲区写数据，解除阻塞，接受客户端连接的时候，会得到一个和客户端通信的套接字fd，这个fd是新的，会有新的读/写缓冲区。

然后来看看客户端的流程，首先创建一个用于通信的套接字fd，然后连接服务器，需要指定连接的服务器的IP和端口，如果连接成功了就可以直接和服务器进行通信。

下图是TCP通信流程。

二、套接字函数

套接字的头文件主要有三个，如下所示。

#include 
#include 

#include  // 包含了这个头文件，上面两个就可以省略

具体的函数有以下几个常用的，接下来挨个来看看作用和使用。

int socket(int domain,int type,int protocol);
int bind(int sockfd,const struct sockaddr *addr, socklen_t addrlen);
int listen(int sockfd,int backlog);
int accept(int sockfd,const struct sockaddr *addr,socklen_t *addrlen);
int connect(int sockfd,const struct sockaddr *addr,socklen_t addrlen);


ssize_t write(int fd,const void *buf,size_t count);
ssize_t read(int fd,void *buf,size_t count);

2.1 socket()

int socket(int domain,int type,int protocol);

功能：创建一个套接字。我们来查看下linux文档中系统函数库中socket的定义。man 2 socket，通过创建一个文件描述符fd进行读写操作。

参数1【domain】：协议族。常见的协议族protocol familiy，也称为domain。协议族的内容都定义在了头文件当中。

AF_INET代表IPv4，AF_INET6代表ipv6，AF_UNIX和AF_LCOAL代表本地套接字通信（也就是进程间通信）。

第二参数【type】：通信过程中使用的协议类型。
SOCK_STREAM流式协议（TCP），SOCK_DGRAM报式协议（如UDP等等）。

第三个参数【protocol】：具体的一个协议，一般写0。
流式报协议默认使用TCP，报式协议默认使用UDP。

这个函数的返回值就是返回文件描述符，这个文件描述符操作的就是内核的一个缓冲区（包括了读和写缓冲区）。失败了就会返回-1。

2.2 bind()

int bind(int sockfd,const struct sockaddr *addr, socklen_t addrlen);

作用就是将fd和本地的IP+端口进行绑定。

三个参数，sockfd是通过socket函数获得的文件描述符fd。addr就是需要绑定的socket地址，封装了ip和端口号的信息。addrlen是第二个参数结构体所占的内存的大小。

2.3 listen()

int listen(int sockfd,int backlog);

作用是进行监听，监听这个socket上的连接。

sockfd就是通过socket()得到的文件描述符，backlog是未连接和已连接的和的最大值。

调用listen在底层会有两个队列，一个是未连接的队列，一个是已经连接的队列。超过了backlog就会丢失。（一般不用指定太大。）

这个backlog最大值在路径/proc/sys/net/core/somaxconn下可以查看到。

2.4 accept()

int accept(int sockfd,const struct sockaddr *addr,socklen_t *addrlen);

接收客户端连接，默认是一个阻塞的函数，阻塞等待客户端连接。

addr：传出参数，记录连接成功后的客户端的地址信息（ip+port）。addrlen：指定第二个参数的对应的内存大小。

成功就返回用于通信的文件描述符，这个文件描述符专门用来通信的，失败了返回-1。

2.5 connect()

int connect(int sockfd,const struct sockaddr *addr,socklen_t addrlen);

这个是客户端用于连接服务器的函数。

sockfd用于通信的文件描述符，调用socket创建的。addr客户端要连接的服务器地址信息。

第三个参数addrlen可以直接sizeof（addrlen），但是上面accpet是不行的，需要定义某个参数=addrlen，然后把这个参数的地址传入给accpet作为第三个参数。

三、demo实现

3.1 server端代码

# include
# include 
# include
# include
# include


int main() {

    //1.创建socket（用于创建套件字）
    // lfd 就是listen_fd，用于监听的fd。
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    //代码健壮性，判断返回值
    if (lfd==-1){
        perror("socket");
        exit(-1);
    }

    //2. bind绑定
    struct sockaddr_in saddr; //需要初始化，不然会随机数据
    saddr.sin_family = AF_INET;
    //把主机字节序转换成网络字节序，然后存给第三个传出参数
    //inet_pton(AF_INET,"127.0.0.1",saddr.sin_addr.s_addr);   
    saddr.sin_addr.s_addr = INADDR_ANY; //服务器端才可以这么写
    saddr.sin_port= htons(9999); //9999是主机字节序，进行网络通信的时候需要转换为网络字节序
    //因为saddr是sockaddr_in类型的指针，所以还需要转换成sockaddr类型的指针
    int ret = bind(lfd, (struct sockaddr *)&saddr,sizeof(saddr) );
    if (ret==-1){
        perror("bind");
        exit(-1);
    }

    //3.监听
    ret = listen(lfd,8);
    if (ret==-1){
        perror("bind");
        exit(-1);
    }

    //4.接收客户端连接
    struct sockaddr_in clientaddr;
    int len = sizeof(clientaddr);
    int cfd = accept(lfd,(struct sockaddr *)&clientaddr,&len);
    if(cfd==-1){
        perror("client");
        exit(-1);
    }

    //5.输出客户端的信息，获取过来的信息是网络字节序，需要转换为主机字节序
    char clientIP[16];
    inet_ntop(AF_INET,&clientaddr.sin_addr.s_addr,clientIP,sizeof(clientIP));
    unsigned short clientPort = ntohs(clientaddr.sin_port);
    printf("client ip is %s,port is %d
",clientIP,clientPort);

    //6.进行通信，先获取客户端的数据，然后给客户端发送数据
    char recvBuf[1024]={0};
    int num = read(cfd,recvBuf,sizeof(recvBuf));
    if(num==-1){
        perror("read");
        exit(-1);
    }else if(num>0){
        printf("recv client data: %s
",recvBuf);
    }else if(num==0){
        //客户端断开连接
        printf("client closed...");
    }


    char *data = "hello,i am server";
    write(cfd,data,strlen(data));

    //关闭文件描述符
    close(lfd);
    close(cfd);
    return 0;
}

3.2 client端代码

# include
# include
# include
# include
# include

int main(){

    //创建套接字
    int fd = socket(AF_INET,SOCK_STREAM,0);
    if(fd==-1){
        perror("socket");
        exit(-1);
    }

    //连接服务器
    struct sockaddr_in serveraddr;
    serveraddr.sin_family = AF_INET;
    inet_pton(AF_INET,"127.0.0.1",&serveraddr.sin_addr.s_addr);
    serveraddr.sin_port = htons(9999);
    int ret = connect(fd,(struct sockaddr *)&serveraddr,sizeof(serveraddr));
    if(fd==-1){
        perror("socket");
        exit(-1);
    } 

    //3.通信
    char *data = "hello,i am client";
    write(fd,data,strlen(data));

    char recvBuf[1024]={0};
    int len = read(fd,recvBuf,sizeof(recvBuf));
    if(len==-1){
        perror("read");
        exit(-1);
    }else if(len>0){
        printf("recv server data: %s
",recvBuf);
    }else if(len==0){
        //客户端断开连接
        printf("server closed...");
    }


    close(fd);

    return 0;
}

上面的代码就是实现了一次的收发。

四、TCP三次握手

我们先看看TCP头部结构中的一些重要数据。

32 位序号(sequence number):一次 TCP 通信(从TCP 连接建立到断开)过程中某一个传输方向上的字节流的每个字节的编号。假设主机A和主机 B进行 TCP 通信，A发送给 B的第一个TCP 报文段中，序号值被系统初始化为某个随机值ISN(Initial Sequence Number，初始序号值)。那么在该传输方向上(从 A到 B)，后续的TCP 报文段中序号值将被系统设置成ISN 加上该报文段所携带数据的第一个字节在整个字节流中的偏移。例如，某个 TCP 报文段传送的数据是字节流中的第 1025~2048 字节，那么该报文段的序号值就是ISN+1025。另外一个传输方向(从B 到 A)的 TCP 报文段的序号值也具有相同的含义。

32 位确认号(acknowedgement number):用作对另一方发送来的TCP 报文段的响应。其值是收到的 TCP 报文段的序号值+标志位长度(SYN，FIN)+数据长度。假设主机A和主机B进行TCP 通信，那么 A发送出的TCP 报文段不仅携带自己的序号，而且包含对B发送来的 TCP 报文段的确认号。反之，B发送出的 TCP 报文段也同样携带自己的序号和对A发送来的报文段的确认序号。

头部长度这个字段是4个字节为单位的，4位最大能够表示15，所以TCP头部的长度最长是60字节。

6位的标志位中最重要的几个分别是ACK、SYN、FIN。
ACK 标志，表示确认号是否有效。我们称携带 ACK 标志的 TCP 报文段为确认报文段。
SYN 标志，表示请求建立一个连接。我们称携带 SYN 标志的 TCP 报文段为同步报文段。
FIN 标志，表示通知对方本端要关闭连接了。我们称携带 FIN 标志的 TCP 报文段为结束报文
段。

三次握手发生在客户端连接的时候，当调用connect的时候，底层会通过TCP协议进行三次握手。

两次握手是不行的，通信双方各自都要确认自己是能收发数据的。

客户端第一次发的时候，只确认了自己能够发。

服务端收到第一次数据之后，能够确认自己的收和客户端的发是没问题的，然后服务端发送ACK确认，进一步又确认了服务端自己的发是没问题的。（此时服务端能够确认自己能够收发，并且客户端能够发。）

然后客户端收到了之后，能够确认服务端能够进行收、发的，并且确认了自己能够没问题的收发。（此时只差服务端能够确认客户端能够正常收到自己所发送的数据，所以还差一次客户端发送，也就是最后一次握手。）

然后最后客户端会再发一次给服务端，服务端收到之后，能够清楚客户端是能够正常收的。

第一次握手：
1.客户端将SYN标志位置为1
2.生成一个随机的32位的序号seq=J ，这个序号后边是可以携带数据（数据的大小）

第二次握手：
1.服务器端接收客户端的连接： ACK=1
2.服务器会回发一个确认序号： ack=客户端的序号 + 数据长度 + SYN/FIN(按一个字节算)
3.服务器端会向客户端发起连接请求： SYN=1
4.服务器会生成一个随机序号：seq = K

第三次握手：
1.客户单应答服务器的连接请求：ACK=1
2.客户端回复收到了服务器端的数据：ack=服务端的序号 + 数据长度 + SYN/FIN(按一个字节算)。

只有当SYN或者FIN为1的时候，ack才会为seq+1，其余的时候都是加上具体的数据。

五、TCP滑动窗口

滑动窗口(Sliding window)是一种流量控制技术。早期的网络通信中，通信双方不会考虑网络的拥挤情况直接发送数据。由于大家不知道网络拥塞状况，同时发送数据，导致中间节点阻塞掉包，谁也发不了数据，所以就有了滑动窗口机制来解决此问题。

滑动窗口协议是用来改善吞吐量的一种技术，即容许发送方在接收任何应答之前传送附加的包。接收方告诉发送方在某一时刻能送多少包(称窗口尺寸)。TCP 中采用滑动窗口来进行传输控制，滑动窗口的大小意味着接收方还有多大的缓冲区可以用于接收数据。发送方可以通过滑动窗口的大小来确定应该发送多少字节的数据。当滑动窗口为 0时，发送方一般不能再发送数据报。

滑动窗口是 TCP 中实现诸如 ACK 确认、流量控制、拥塞控制的承载结构。

窗口可以理解为缓冲区的大小，滑动窗口的大小会随着发送数据和接收数据而变化。通信的双方都有发送缓冲区和接收数据的缓冲区。

下图中的一些数据说明，mssMaximum Segment Size，一条数据的最大数据量。win：Windows，滑动窗口。

六、TCP四次挥手

四次挥手发生在断开连接的时候，在程序当中调用了close()使用TCP协议进行四次挥手。

客户端和服务端都可以主动发起断开连接，谁先调用close谁就是发起者。

因为连接是双向的，所以断开的时候也需要双向断开。

七、多进程并发服务器

在main函数中，程序首先通过sigaction系统调用注册了SIGCHLD信号的处理函数，确保能够及时回收子进程。接着，程序创建了一个TCP套接字，并将其绑定到本地的9999端口上，然后进入监听状态，等待客户端的连接请求。一旦有客户端连接，服务器会通过accept函数接受连接，并为每个连接创建一个子进程来处理与该客户端的通信。子进程会获取客户端的IP地址和端口号，并通过循环不断读取客户端发送的数据，然后将接收到的数据原样发送回客户端，直到客户端关闭连接。子进程在处理完客户端请求后会退出。父进程则继续等待新的客户端连接。

信号处理函数recyleChild，用于回收子进程，防止僵尸进程的产生。当收到SIGCHLD信号时，该函数会调用waitpid函数以非阻塞的方式回收所有已经结束的子进程，并打印被回收子进程的PID。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

void recyleChild(int arg) {
    while(1) {
        int ret = waitpid(-1, NULL, WNOHANG);
        if(ret == -1) {
            // 所有的子进程都回收了
            break;
        }else if(ret == 0) {
            // 还有子进程活着
            break;
        } else if(ret > 0){
            // 被回收了
            printf("子进程 %d 被回收了
", ret);
        }
    }
}

int main() {

    struct sigaction act;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    act.sa_handler = recyleChild;
    // 注册信号捕捉
    sigaction(SIGCHLD, &act, NULL);
    

    // 创建socket
    int lfd = socket(PF_INET, SOCK_STREAM, 0);
    if(lfd == -1){
        perror("socket");
        exit(-1);
    }

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    saddr.sin_addr.s_addr = INADDR_ANY;

    // 绑定
    int ret = bind(lfd,(struct sockaddr *)&saddr, sizeof(saddr));
    if(ret == -1) {
        perror("bind");
        exit(-1);
    }

    // 监听
    ret = listen(lfd, 128);
    if(ret == -1) {
        perror("listen");
        exit(-1);
    }

    // 不断循环等待客户端连接
    while(1) {

        struct sockaddr_in cliaddr;
        int len = sizeof(cliaddr);
        // 接受连接
        int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);
        if(cfd == -1) {
            if(errno == EINTR) {
                continue;
            }
            perror("accept");
            exit(-1);
        }

        // 每一个连接进来，创建一个子进程跟客户端通信
        pid_t pid = fork();
        if(pid == 0) {
            // 子进程
            // 获取客户端的信息
            char cliIp[16];
            inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, cliIp, sizeof(cliIp));
            unsigned short cliPort = ntohs(cliaddr.sin_port);
            printf("client ip is : %s, port is %d
", cliIp, cliPort);

            // 接收客户端发来的数据
            char recvBuf[1024];
            while(1) {
                int len = read(cfd, &recvBuf, sizeof(recvBuf));

                if(len == -1) {
                    perror("read");
                    exit(-1);
                }else if(len > 0) {
                    printf("recv client : %s
", recvBuf);
                } else if(len == 0) {
                    printf("client closed....
");
                    break;//这个break也是有作用的，如果不break就会输出两次close，因为会继续到write，然后到循环，然后又判一次close
                }
                write(cfd, recvBuf, strlen(recvBuf) + 1);
            }
            close(cfd);
            exit(0);    // 退出当前子进程
        }

    }
    close(lfd);
    return 0;
}

这里简单回顾下信号集的知识点。之所以不使用wait是因为会阻塞。

    //SIGCHLD信号是在子进程结束时由操作系统发送给父进程的信号。
    //sigaction是POSIX标准中用于信号处理的结构体
    //sa_flags是一个标志位，用于控制信号处理的特殊行为。
    //将它设置为0表示不启用任何特殊行为，即使用默认的信号处理方式。
    //调用了sigemptyset函数，用于初始化act.sa_mask.
    //sa_mask是一个信号集，用于指定在信号处理函数执行期间需要屏蔽的信号。
    //sigemptyset函数的作用是清空信号集，即不屏蔽任何信号。
    struct sigaction act;  
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    act.sa_handler = recyleChild;
    // 注册信号捕捉
    sigaction(SIGCHLD, &act, NULL);

客户端代码如下。

// TCP通信的客户端
#include 
#include 
#include 
#include 
#include 

int main() {

    // 1.创建套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if(fd == -1) {
        perror("socket");
        exit(-1);
    }

    // 2.连接服务器端
    struct sockaddr_in serveraddr;
    serveraddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &serveraddr.sin_addr.s_addr);
    serveraddr.sin_port = htons(9999);
    int ret = connect(fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));

    if(ret == -1) {
        perror("connect");
        exit(-1);
    }
    
    // 3. 通信
    char recvBuf[1024];
    int i = 0;
    while(1) {
        
        sprintf(recvBuf, "data : %d
", i++);
        
        // 给服务器端发送数据
        //这里+1 是因为要算进去字符换行的结束符，不然会有问题。
        //服务器端write也是同理的。
        write(fd, recvBuf, strlen(recvBuf)+1);

        int len = read(fd, recvBuf, sizeof(recvBuf));
        if(len == -1) {
            perror("read");
            exit(-1);
        } else if(len > 0) {
            printf("recv server : %s
", recvBuf);
        } else if(len == 0) {
            // 表示服务器端断开连接
            printf("server closed...");
            break;
        }

        sleep(1);
    }

    // 关闭连接
    close(fd);

    return 0;
}

这里有个需要注意的地方是，在strlen(recvBuf)后面进行了+1的操作。在处理字符串时，strlen函数返回字符串的实际长度，但不包括字符串末尾的空字符（‘’）。然而，C语言中的字符串是以空字符结尾的，因此在将字符串写入套接字时，如果需要将整个字符串（包括空字符）发送给客户端，就需要在strlen返回的长度基础上加1。

另外还有一个点需要注意，服务端中的代码：

当某个子进程退出的时候，会产生信号，然后执行回调，执行回调就相当于一个软中断，软终端会产生一个错误EINTR，执行完中断之后会回到accpet，然后继续执行accpet，但是这个时候会执行不了，会出错，会返回-01，然后导致退出进程。

也就是说，accept是一个阻塞系统调用，用于等待客户端的连接请求。当父进程正在执行accept时，如果子进程退出，操作系统会发送SIGCHLD信号给父进程。父进程接收到SIGCHLD信号后，会中断当前的accept调用，并执行信号处理函数recyleChild。信号处理函数执行完成后，accept调用会返回-1，并将errno设置为EINTR，表示系统调用被中断了。

所以需要改进下面的代码。

        int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);
        if(cfd == -1) {
            perror("accept");
            exit(-1);
        }

改进后的代码如下所示。

        int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len);
        if(cfd == -1) {
            if(errno == EINTR) {
                continue;
            }
            perror("accept");
            exit(-1);
        }