为什么Linux上的非阻塞TCP connect（）有时会这么慢？

我试图测量我正在编写的TCP服务器的速度，我注意到测量connect（）调用的速度可能存在一个基本问题：如果我以非阻塞方式连接，connect（）操作在几秒钟后会变得非常慢。以下是Python中的示例代码：

#! /usr/bin/python2.4
import errno
import os
import select
import socket
import sys
import time

def NonBlockingConnect(sock, addr):
  #time.sleep(0.0001)  # Fixes the problem.
  while True:
    try:
      return sock.connect(addr)
    except socket.error, e:
      if e.args[0] not in (errno.EINPROGRESS, errno.EALREADY):
        raise
      os.write(2, '^')
      if not select.select((), (sock,), (), 0.5)[1]:
        os.write(2, 'P')

def InfiniteClient(addr):
  while True:
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
    sock.setblocking(0)
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    # sock.connect(addr)
    NonBlockingConnect(sock, addr)
    sock.close()
    os.write(2, '.')

def InfiniteServer(server_socket):
  while True:
    sock, addr = server_socket.accept()
    sock.close()

server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(('127.0.0.1', 45454))
server_socket.listen(128)

if os.fork():  # Parent.
  InfiniteServer(server_socket)
else:
  addr = server_socket.getsockname()
  server_socket.close()
  InfiniteClient(addr)

使用

NonBlockingConnect

，大多数connect（）操作都很快，但每隔几秒钟就会有一个connect（）操作，至少需要2秒钟（如输出上连续的5个

p

字母所示）。通过使用

sock.connect

而不是

NonBlockingConnect

所有连接操作似乎都很快

如何摆脱这些缓慢的connect（）呢

我使用标准PAE内核运行Ubuntu Karmic desktop：

Linux narancs 2.6.31-20-generic-pae #57-Ubuntu SMP Mon Feb 8 10:23:59 UTC 2010 i686 GNU/Linux

奇怪的是，

strace-f./conn.py

没有延迟

奇怪的是，如果我取消注释非常快的

time.sleep

，没有延迟

奇怪的是，我的Ubuntu Hardy系统没有延迟：

所有这些系统都受到影响（运行Ubuntu Karmic、Ubuntu Hardy、Debian Etch）：

奇怪的是，以下Debian Lenny系统没有受到影响：

Linux t 2.6.31.5 #2 SMP Thu Nov 5 15:33:05 CET 2009 i686 GNU/Linux

仅供参考，如果使用AF_UNIX套接字，则不会出现延迟

仅供参考，如果我在C中实现客户端，我会得到相同的行为：

/* by pts@fazekas.hu at Sun Apr 25 20:47:24 CEST 2010 */
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <unistd.h>

static int work(void) {
  fd_set rset;
  fd_set wset;
  fd_set eset;
  socklen_t sl; 
  struct timeval timeout;
  struct sockaddr_in sa;
  int sd, i, j;
  long l;
  sd = socket(AF_INET, SOCK_STREAM, 0);
  if (sd < 0) {
    perror("socket");
    return 2;
  }
  l = fcntl(sd, F_GETFL, 0);
  if (l < 0) {
    perror("fcntl-getfl");
    close(sd);
    return 2;
  }
  if (0 != fcntl(sd, F_SETFL, l | O_NONBLOCK)) {
    perror("fcntl-setfl");
    close(sd);
    return 2;
  }
  memset(&sa, '\0', sizeof(sa));
  sa.sin_family = AF_INET;
  sa.sin_port = htons(45454);
  sa.sin_addr.s_addr = inet_addr("127.0.0.1");
  while (0 != connect(sd, (struct sockaddr*)&sa, sizeof sa)) {
    if (errno != EAGAIN && errno != EINPROGRESS && errno != EALREADY) {
      perror("connect");
      close(sd);
      return 2;
    }
    FD_ZERO(&rset);
    FD_ZERO(&wset);
    FD_ZERO(&eset);

    j = 0;
    do {
      timeout.tv_sec = 0;
      timeout.tv_usec = 100 * 1000;  /* 0.1 sec */
      FD_SET(sd, &wset);
      FD_SET(sd, &eset);
      i = select(sd + 1, &rset, &wset, &eset, &timeout);
      if (i < 0) {
        perror("select");
        close(sd);
        return 2;
      }  
      if (++j == 5) {
        (void)write(2, "P", 1);
        j = 0;
      }
    } while (i == 0);
    sl = sizeof i;
    if (0 != getsockopt(sd, SOL_SOCKET, SO_ERROR, &i, &sl)) {
      perror("getsockopt");
      close(sd);
      return 2;
    }
    if (i != 0) {
      if (i == ECONNRESET) {
        (void)write(2, "R", 1);
        close(sd);
        return -3;
      }
      fprintf(stderr, "connect-SO_ERROR: %s\n", strerror(i));
      close(sd);
      return 2;
    }
  }
  close(sd);
  return 0;
}

int main(int argc, char**argv) {
  int i;
  (void)argc;
  (void)argv;
  while ((i = work()) <= 0) (void)write(2, ".", 1);
  return i;
}

/*bypts@fazekas.hu2010年4月25日星期日20:47:24 CEST*/
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
静态整型工作（无效）{
fd_集rset；
fd_集wset；
fd_集eset；
socklen_t sl；
结构timeval超时；
sa中的结构sockaddr_；
int-sd，i，j；
长l；
sd=套接字（AF_INET，SOCK_STREAM，0）；
如果（sd<0）{
佩罗（“插座”）；
返回2；
}
l=fcntl（标准差，F_GETFL，0）；
if（l<0）{
perror（“fcntl getfl”）；
关闭（sd）；
返回2；
}
如果（0！=fcntl（sd，F|U设置FL，l|O|U非块））{
perror（“fcntl setfl”）；
关闭（sd）；
返回2；
}
memset（&sa，'\0'，sizeof（sa））；
sa.sin_family=AF_INET；
sa.sin_port=htons（45454）；
sa.sin_addr.s_addr=inet_addr（“127.0.0.1”）；
而（0！=connect（sd，（struct sockaddr*）&sa，sizeof sa））{
if（errno！=EAGAIN&&errno！=EINPROGRESS&&errno！=EALREADY）{
perror（“连接”）；
关闭（sd）；
返回2；
}
FD_零和rset；
FD_零（和wset）；
FD_ZERO（和eset）；
j=0；
做{
timeout.tv_sec=0；
timeout.tv_usec=100*1000；/*0.1秒*/
FD_集（sd和wset）；
FD_集（sd和eset）；
i=选择（sd+1、&rset、&wset、&eset和超时）；
if（i<0）{
佩罗（“选择”）；
关闭（sd）；
返回2；
}  
如果（++j==5）{
（无效）写（2，“P”，1）；
j=0；
}
}而（i==0）；
sl=i的尺寸；
if（0！=getsockopt（sd、SOL\u SOCKET、SO\u ERROR、&i和&sl））{
perror（“getsockopt”）；
关闭（sd）；
返回2；
}
如果（i！=0）{
如果（i==ECONNRESET）{
（无效）写（2，“R”，1）；
关闭（sd）；
返回-3；
}
fprintf（stderr，“connect-SO_错误：%s\n”，strerror（i））；
关闭（sd）；
返回2；
}
}
关闭（sd）；
返回0；
}
int main（int argc，字符**argv）{
int i；
（无效）argc；
（无效）argv；
而（（i=work（））您确定这是
connect（）吗
调用慢的一个？在大多数库中，DNS解析总是阻塞。检查始终使用IP地址是否有任何区别。
鉴于睡眠和strace会导致问题消失，这看起来像是一些调度问题，其中服务器进程没有安排接受连接。尽管没有安排服务在2秒钟的时间里，r是一个非常长的时间

也许像latencytop这样的工具可能有助于揭示发生了什么。你可能只能在Karmic（2.6.31）上运行它，因为我认为其他内核太旧了。
我正在运行问题中包含的代码。那里没有DNS解析。请注意
sock.connect（（主机，端口））
将很乐意解决
主机
如果它看起来不像IP号码。我知道
sock.connect（（主机，端口））
将解析
主机
。但这与我的情况完全无关，在问题中的示例代码中，我使用IP地址，它仍然很慢。此外，我还使用
strace
分析了程序，它不尝试任何DNS解析，或任何其他明显很慢的操作。服务器进程确实得到了调度。当我执行非阻塞接受（）+选择（）在服务器进程中，选择（）返回超时。因此1.服务器执行非阻塞接受（）；2.服务器执行选择（超时=3）3.客户端执行非阻塞连接（）；4.服务器执行选择（超时=3）；5.两个选择（）都返回超时。因此服务器希望接受（），客户端希望连接（），那么为什么不在第500种情况下发生连接？
/* by pts@fazekas.hu at Sun Apr 25 20:47:24 CEST 2010 */
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <unistd.h>

static int work(void) {
  fd_set rset;
  fd_set wset;
  fd_set eset;
  socklen_t sl; 
  struct timeval timeout;
  struct sockaddr_in sa;
  int sd, i, j;
  long l;
  sd = socket(AF_INET, SOCK_STREAM, 0);
  if (sd < 0) {
    perror("socket");
    return 2;
  }
  l = fcntl(sd, F_GETFL, 0);
  if (l < 0) {
    perror("fcntl-getfl");
    close(sd);
    return 2;
  }
  if (0 != fcntl(sd, F_SETFL, l | O_NONBLOCK)) {
    perror("fcntl-setfl");
    close(sd);
    return 2;
  }
  memset(&sa, '\0', sizeof(sa));
  sa.sin_family = AF_INET;
  sa.sin_port = htons(45454);
  sa.sin_addr.s_addr = inet_addr("127.0.0.1");
  while (0 != connect(sd, (struct sockaddr*)&sa, sizeof sa)) {
    if (errno != EAGAIN && errno != EINPROGRESS && errno != EALREADY) {
      perror("connect");
      close(sd);
      return 2;
    }
    FD_ZERO(&rset);
    FD_ZERO(&wset);
    FD_ZERO(&eset);

    j = 0;
    do {
      timeout.tv_sec = 0;
      timeout.tv_usec = 100 * 1000;  /* 0.1 sec */
      FD_SET(sd, &wset);
      FD_SET(sd, &eset);
      i = select(sd + 1, &rset, &wset, &eset, &timeout);
      if (i < 0) {
        perror("select");
        close(sd);
        return 2;
      }  
      if (++j == 5) {
        (void)write(2, "P", 1);
        j = 0;
      }
    } while (i == 0);
    sl = sizeof i;
    if (0 != getsockopt(sd, SOL_SOCKET, SO_ERROR, &i, &sl)) {
      perror("getsockopt");
      close(sd);
      return 2;
    }
    if (i != 0) {
      if (i == ECONNRESET) {
        (void)write(2, "R", 1);
        close(sd);
        return -3;
      }
      fprintf(stderr, "connect-SO_ERROR: %s\n", strerror(i));
      close(sd);
      return 2;
    }
  }
  close(sd);
  return 0;
}

int main(int argc, char**argv) {
  int i;
  (void)argc;
  (void)argv;
  while ((i = work()) <= 0) (void)write(2, ".", 1);
  return i;
}