为什么下面的代码很慢？我所说的慢是指 100x-1000x 慢。它只是重复地直接在 TCP 套接字上执行读/写。奇怪的是，只有当我使用两个函数调用来读取和写入时，它才会保持缓慢，如下所示。如果我更改服务器或客户端代码以使用单个函数调用(如评论中所述)，它会变得非常快。

代码片段:

int main(...) {
  int sock = ...; // open TCP socket
  int i;
  char buf[100000];
  for(i=0;i<2000;++i)
  { if(amServer)
    { write(sock,buf,10);
      // read(sock,buf,20);
      read(sock,buf,10);
      read(sock,buf,10);
    }else
    { read(sock,buf,10);
      // write(sock,buf,20);
      write(sock,buf,10);
      write(sock,buf,10);
    }
  }
  close(sock);
}

我们在一个更大的程序中偶然发现了这个，它实际上使用了 stdio 缓冲。当负载大小略微超过缓冲区大小时，它神秘地变得迟缓。然后我用 strace 做了一些挖掘，最后把问题归结为这个。我可以通过使用缓冲策略来解决这个问题，但我真的很想知道这里到底发生了什么。在我的机器上，当我将两个读取调用更改为单个调用时，它在我的机器上从 0.030 秒增加到一分钟多(在本地和远程机器上测试)。

这些测试是在各种 Linux 发行版和各种内核版本上完成的。相同的结果。

带有网络样板的完全可运行代码:

#include <netdb.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/ip.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>

static int getsockaddr(const char* name,const char* port, struct sockaddr* res)
{
    struct addrinfo* list;
    if(getaddrinfo(name,port,NULL,&list) < 0) return -1;
    for(;list!=NULL && list->ai_family!=AF_INET;list=list->ai_next);
    if(!list) return -1;
    memcpy(res,list->ai_addr,list->ai_addrlen);
    freeaddrinfo(list);
    return 0;
}
// used as sock=tcpConnect(...); ...; close(sock);
static int tcpConnect(struct sockaddr_in* sa)
{
    int outsock;
    if((outsock=socket(AF_INET,SOCK_STREAM,0))<0) return -1;
    if(connect(outsock,(struct sockaddr*)sa,sizeof(*sa))<0) return -1;
    return outsock;
}
int tcpConnectTo(const char* server, const char* port)
{
    struct sockaddr_in sa;
    if(getsockaddr(server,port,(struct sockaddr*)&sa)<0) return -1;
    int sock=tcpConnect(&sa); if(sock<0) return -1;
    return sock;
}

int tcpListenAny(const char* portn)
{
    in_port_t port;
    int outsock;
    if(sscanf(portn,"%hu",&port)<1) return -1;
    if((outsock=socket(AF_INET,SOCK_STREAM,0))<0) return -1;
    int reuse = 1;
    if(setsockopt(outsock,SOL_SOCKET,SO_REUSEADDR,
              (const char*)&reuse,sizeof(reuse))<0) return fprintf(stderr,"setsockopt() failed\n"),-1;
    struct sockaddr_in sa = { .sin_family=AF_INET, .sin_port=htons(port)
                  , .sin_addr={INADDR_ANY} };
    if(bind(outsock,(struct sockaddr*)&sa,sizeof(sa))<0) return fprintf(stderr,"Bind failed\n"),-1;
    if(listen(outsock,SOMAXCONN)<0) return fprintf(stderr,"Listen failed\n"),-1;
    return outsock;
}

int tcpAccept(const char* port)
{
    int listenSock, sock;
    listenSock = tcpListenAny(port);
    if((sock=accept(listenSock,0,0))<0) return fprintf(stderr,"Accept failed\n"),-1;
    close(listenSock);
    return sock;
}

void writeLoop(int fd,const char* buf,size_t n)
{
    // Don't even bother incrementing buffer pointer
    while(n) n-=write(fd,buf,n);
}
void readLoop(int fd,char* buf,size_t n)
{
    while(n) n-=read(fd,buf,n);
}
int main(int argc,char* argv[])
{
    if(argc<3)
    { fprintf(stderr,"Usage: round {server_addr|--} port\n");
        return -1;
    }
    bool amServer = (strcmp("--",argv[1])==0);
    int sock;
    if(amServer) sock=tcpAccept(argv[2]);
    else sock=tcpConnectTo(argv[1],argv[2]);
    if(sock<0) { fprintf(stderr,"Connection failed\n"); return -1; }

    int i;
    char buf[100000] = { 0 };
    for(i=0;i<4000;++i)
    {
        if(amServer)
        { writeLoop(sock,buf,10);
            readLoop(sock,buf,20);
            //readLoop(sock,buf,10);
            //readLoop(sock,buf,10);
        }else
        { readLoop(sock,buf,10);
            writeLoop(sock,buf,20);
            //writeLoop(sock,buf,10);
            //writeLoop(sock,buf,10);
        }
    }

    close(sock);
    return 0;
}

编辑:此版本与其他代码片段略有不同，因为它在循环中读取/写入。所以在这个版本中，两个单独的写入自动导致两个单独的 read() 调用，即使 readLoop 只被调用一次。但否则问题仍然存在。

最佳答案

很有趣。您是 Nagle's algorithm 的受害者连同 TCP delayed acknowledgements .

Nagle 算法是 TCP 中使用的一种机制，用于延迟小数据段的传输，直到积累了足够的数据，值得在网络上构建和发送数据段。来自维基百科文章:

Nagle's algorithm works by combining a number of small outgoing messages, and sending them all at once. Specifically, as long as there is a sent packet for which the sender has received no acknowledgment, the sender should keep buffering its output until it has a full packet's worth of output, so that output can be sent all at once.

但是，TCP 通常采用称为 TCP 延迟确认 的技术，该技术包括将一批 ACK 回复累积在一起(因为 TCP 使用累积 ACKS)，以减少网络流量。

那篇维基百科文章进一步提到了这一点:

With both algorithms enabled, applications that do two successive writes to a TCP connection, followed by a read that will not be fulfilled until after the data from the second write has reached the destination, experience a constant delay of up to 500 milliseconds, the "ACK delay".

(强调我的)

在您的特定情况下，由于服务器在读取回复之前没有发送更多数据，因此客户端会导致延迟:如果客户端写入两次，the second write will be delayed .

If Nagle's algorithm is being used by the sending party, data will be queued by the sender until an ACK is received. If the sender does not send enough data to fill the maximum segment size (for example, if it performs two small writes followed by a blocking read) then the transfer will pause up to the ACK delay timeout.

因此，当客户端进行 2 次写入调用时，会发生以下情况:

1. 客户端发出第一次写入。
2. 服务器接收到一些数据。它不承认它是希望更多数据到达(因此它可以在一个 ACK​​ 中批量处理一堆 ACK)。
3. 客户端发出第二次写入。之前的写入尚未得到确认，因此 Nagle 的算法会延迟传输，直到更多数据到达(直到收集到足够的数据来制作一个段)或之前的写入被确认。
4. 服务器厌倦了等待，并在 500 毫秒后确认该段。
5. 客户端终于完成了第二次写入。

写入 1 次后，会发生以下情况:

1. 客户端发出第一次写入。
2. 服务器接收到一些数据。它不承认它是希望更多数据到达(因此它可以在一个 ACK​​ 中批量处理一堆 ACK)。
3. 服务器写入套接字。 ACK 是 TCP header 的一部分，因此如果您正在编写，您也可以免费确认前一段。做吧。
4. 与此同时，客户端写入了一次，因此它已经在等待下一次读取 - 没有第二次写入等待服务器的 ACK。

如果你想在客户端继续写两次，你需要禁用Nagle的算法。这是算法作者自己提出的解决方案:

The user-level solution is to avoid write-write-read sequences on sockets. write-read-write-read is fine. write-write-write is fine. But write-write-read is a killer. So, if you can, buffer up your little writes to TCP and send them all at once. Using the standard UNIX I/O package and flushing write before each read usually works.

( See the citation on Wikipedia )

As mentioned by David Schwartz in the comments ，由于各种原因，这可能不是最好的主意，但它说明了这一点并表明这确实导致了延迟。

要禁用它，您需要使用 setsockopt(2) 在套接字上设置 TCP_NODELAY 选项。

这可以在客户端的 tcpConnectTo() 中完成:

int tcpConnectTo(const char* server, const char* port)
{
    struct sockaddr_in sa;
    if(getsockaddr(server,port,(struct sockaddr*)&sa)<0) return -1;
    int sock=tcpConnect(&sa); if(sock<0) return -1;

    int val = 1;
    if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)) < 0)
        perror("setsockopt(2) error");

    return sock;
}

在服务器的 tcpAccept() 中:

int tcpAccept(const char* port)
{
    int listenSock, sock;
    listenSock = tcpListenAny(port);
    if((sock=accept(listenSock,0,0))<0) return fprintf(stderr,"Accept failed\n"),-1;
    close(listenSock);

    int val = 1;
    if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val)) < 0)
        perror("setsockopt(2) error");

    return sock;
}

看到这造成的巨大差异很有趣。

如果您不想弄乱套接字选项，那么确保客户端在下一次读取之前写入一次(且仅写入一次)就足够了。您仍然可以让服务器读取两次:

for(i=0;i<4000;++i)
{
    if(amServer)
    { writeLoop(sock,buf,10);
        //readLoop(sock,buf,20);
        readLoop(sock,buf,10);
        readLoop(sock,buf,10);
    }else
    { readLoop(sock,buf,10);
        writeLoop(sock,buf,20);
        //writeLoop(sock,buf,10);
        //writeLoop(sock,buf,10);
    }
}

关于c - 如果在多个系统调用中完成，为什么 TCP 套接字会变慢？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32274907/