一道高频腾讯面试题：tcp数据发送问题

2022年07月15日20:52:27 科技 1165

问题引出

好几个读者私信说在腾讯面试过程中，被面试官问到了一个问题：“一个tcp服务端和一个tcp客户端，客户端和服务端建立连接后，服务端一直sleep，然后客户端一直发送数据会是什么现象”。

要回答这个问题，需要我们清楚tcp协议的特点和tcp发送数据的大体过程。

tcp发送数据过程

恐怕接触过网络的同学都知道tcp是面向连接的可靠传输协议，意味着客户端发送的数据服务端是一定能够收到的，那么对于上面的问题就不可能存在数据的丢弃。下面我们分析一下tcp的传输过程。

如图所示，tcp数据包的传输过程主要有如下几个步骤：

• 1.应用程序调用write系列函数发送数据，数据首先由应用程序缓冲区复制到发送端的内核中的套接字发送缓冲区，然后write成功返回；需要特别注意的是write成功返回只是说明数据成功的由应用进程缓冲区复制到了套接字发送缓冲区，并不代表数据发送到了对端主机。
• 2.内核协议栈将套接字发送缓冲区中的数据发送到对端主机，这个过程不受应用程序控制，而是发送端内核协议栈完成；
• 3.数据到达接收端主机的套接字接收缓冲区，注意这个接收过程也不受应用程序控制，而是由接收端内核协议栈完成；
• 4.数据由套接字接收缓冲区复制到接收端应用程序缓冲区，注意这个过程是由类似read等函数来完成。

清楚了tcp的传输过程，现在我们分情况来讨论上面的问题。

相关视频推荐

阻塞方式的情况

write系列函数的工作方式默认是阻塞方式：调用write函数时，内核从应用进程的缓冲区到套接字的发送缓冲区复制数据。如果其发送缓冲区中没有空间，进程将进入睡眠，直到有空间为止。

因此，阻塞方式下，如果服务端一直sleep不接收数据，而客户端一直write，也就是只能执行上述过程中的前三步，这样最后接收端的套接字接收缓冲区和发送端套接字发送缓冲区都被填满，这样write就无法继续将数据从应用程序复制到发送端的套接字发送缓冲区了，从而发送端进程进入睡眠。可以用下面的程序验证。

tcpClient.c是客户端代码用来发送数据，客户端每次write成功一次，将计数器count加1，同时输出本次write成功的字节数。count保存客户端write成功的次数。

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <memory.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define PORT 8888
#define Buflen 1024
int main(int argc,char *argv[])
{
    struct sockaddr_in server_addr;
    int n,count=0;
    int sockfd;
    char sendline[Buflen];
    sockfd= socket(AF_INET,SOCK_STREAM,0);
    memset(&server_addr,0,sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);
    connect(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr));

    //与服务器端进行通信
    memset(sendline,'x',sizeof(Buflen));

    while ( (n=write(sockfd,sendline,Buflen))>0 )
    {
        count++;
        printf("already write %d bytes -- %d\n",n,count);
    }

    if(n<0)
        perror("write error");
    close(sockfd);
}

下面的tcpServer.c是服务端程序，服务端并不接收数据。

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <memory.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#define PORT 8888 //定义通信端口
#define BACKLOG 5 //定义侦听队列长度
#define buflen 1024
int listenfd,connfd;
int main(int argc,char *argv[])
{
    struct sockaddr_in server_addr; //存储服务器端socket地址结构
    struct sockaddr_in client_addr; //存储客户端 socket地址结构
    pid_t pid;
    listenfd = socket(AF_INET,SOCK_STREAM,0);
    memset(&server_addr,0,sizeof(server_addr));
    server_addr.sin_family = AF_INET; //协议族
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY); //本地地址
    server_addr.sin_port = htons(PORT);
    bind(listenfd,(struct sockaddr *)&server_addr,sizeof(server_addr));
    listen(listenfd,BACKLOG);
    for(;;)
    {
        socklen_t addrlen = sizeof(client_addr);
        connfd = accept(listenfd,(struct sockaddr *)&client_addr,&addrlen);
        if(connfd<0)
            perror("accept error");
        printf("receive connection\n");
        if((pid = fork()) == 0)
        {
            close(listenfd);
            sleep(1000);//子进程不接收数据，sleep 1000秒
            exit(0);
        }
        else
        {
            close(connfd);
        }
    }
}

首先编译运行服务端，然后启动客户端，运行结果如下：

可以看到客户端write成功377次后就陷入了阻塞，注意这个时候不能说明发送端的套接字发送缓冲区一定是满的，只能说明套接字发送缓冲区的可用空间小于write请求写的自己数——1024。

非阻塞方式的情况

下面看一下非阻塞套接字情况下，write的工作方式：对于一个非阻塞的TCP套接字，如果发送缓冲区中根本没用空间，输出函数将立即返回一个EWOULDBLOCK错误。如果发送缓冲区中有一些空间，返回值将是内核能够复制到该缓冲区的字节数。这个字节数也成为“不足计数”。

这样就可以知道非阻塞情况下服务端一直sleep，客户端一直write数据的效果了：开始客户端write成功，随着客户端write，接收端的套接字接收缓冲区和发送端的套接字发送缓冲区会被填满。当发送端的套接字发送缓冲区的可用空间小于write请求写的字节数时，write立即返回-1，并将errno置为EWOULDBLOCK。

可以用下面的程序验证，其中，服务端程序代码和上面例子一样，我们只看客户端非阻塞模式代码：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <memory.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <errno.h>
#define PORT 8888
#define Buflen 1024
int main(int argc,char *argv[])
{
    struct sockaddr_in server_addr;
    int n,flags,count=0;
    int sockfd;
    char sendline[Buflen];
    sockfd= socket(AF_INET,SOCK_STREAM,0);
    memset(&server_addr,0,sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(PORT);
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_addr.s_addr = inet_addr(argv[1]);
    connect(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr));
    flags=fcntl(sockfd,F_GETFL,0); //将已连接的套接字设置为非阻塞模式
    fcntl(sockfd,F_SETFL,flags|O_NONBLOCK);
    memset(sendline,'a',sizeof(Buflen));
    
    while ( (n=write(sockfd,sendline,Buflen))>0 )
   {
     count++;
     printf("already write %d bytes -- %d\n",n,count);
   }
    
   if(n<0)
  {
    if(errno!=EWOULDBLOCK)
       perror("write error");
    else
       printf("EWOULDBLOCK ERROR\n"); 
  }
   close(sockfd);
}