关于非阻塞connnect的看法

关于非阻塞connnect的总结

在面试题中，看到有关于阻塞connect和非阻塞connect的区别；

显然，我们可以从阻塞和非阻塞的意思来回答，既然是阻塞，那么执行connect的操作会一直阻塞到连接超时或者连接成功才会返回相应的信息，而非阻塞connect则不管是否连接成功，都会立即返回信息。

但是有几个点需要注意：

1. 阻塞超时以后应该如何进行接下来的操作；
2. 在非阻塞连接失败以后，接下来应该如何操作；

先来看第一个问题，个人认为应该继续的进行connect，可以通过设定一个时间范围，超过这个时间范围以后则继续的connect；再看第二个问题，由于conncect是非阻塞的，不会一直等待到成功或者超时的结果，这样我们就无法知道它是否已经成功连接上了，那么我们可以通过select去轮询它，每隔一段时间就去检查服务器套接口，询问服务器的套接口是否存在可读或者可写或者是错误信息，为什么这么做呢？因为如果connect连接上了的时候，select则会监听到存在请求到达的事件，那么它就会返回一个可写的消息，我们就通过这么一个返回值来决定我们是否还要继续connect，但是如果返回0，说明select在指定的事件内并没监听到任何可读或者可写的事件，那么我们则返回超时错误，并且断掉握手连接。

但是，这样的解决方案中会存在几个问题：

1. 我们之前已经提到过了，如果存在错误的信息，那么就会返回一个可读并且可写的信息，应该如何分辨成功还是错误；

如果存在可写的消息，则继续通过getsocketopt中的返回值判断是否存在错误，接着通过错误参数去判断是什么错误信息，其错误信息可能是连接超时，连接错误等等，根据错误信息决定接下来的操作；如果此时其返回为0，显然这个时候没有错误，再进行接下里的操作；

但是，但是网上上面的操作方案说这么做依然会存在这么一个移植性的问题，说是Berkeley的实现中getsocketopt如果有错误的话返回的是0，但是我上网查了一下，并不是这样的，难道是我查的姿势不对？具体网址是这里。除此之外，还有存在另外一个问题，就是在select之前，已经建立了连接，并且此时对方的数据要发送过来，那么此时再进行select，那么它就会返回同样的可读并且可写的消息，跟错误信息返回的是一样的，那么我们之前定义其已经连接的方法就不再唯一。如果我们想要获取准确唯一的获取当前是否已经连接，可以通过下面的办法：

1. 先通过getpeername获取远程协议地址，如果之前已经连接了，那么它可以返回，但是如果是报错信息，那么显然返回错误，然后再通过getsockopt获取相应的错误信息；
2. 通过read读取0字节的数据，如果是存在数据，那么可以读取，但是如果是错误信息，因为之前并没有建立连接，所以它会返回相应的错误信息；
3. 再次的connect，如果之前已经建立了连接，那么它的返回就是EISCONN，但是如果是错误信息，那么就会返回失败信息。

---

我们可以通过Redis的代码去了解如何实现非阻塞connect。

通过函数fcntl设置非阻塞或者阻塞

static int redisSetBlocking(redisContext *c, int fd, int blocking) {
    int flags;
    /* Set the socket nonblocking.
     * Note that fcntl(2) for F_GETFL and F_SETFL can't be
     * interrupted by a signal. */
    if ((flags = fcntl(fd, F_GETFL)) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_GETFL)");
        close(fd);
        return REDIS_ERR;
    }
    if (blocking)
        flags &= ~O_NONBLOCK;
    else
        flags |= O_NONBLOCK;
    if (fcntl(fd, F_SETFL, flags) == -1) {
        __redisSetErrorFromErrno(c,REDIS_ERR_IO,"fcntl(F_SETFL)");
        close(fd);
        return REDIS_ERR;
    }
    return REDIS_OK;
}

核心函数，有一点不太明白，为什么redis上下文是非阻塞的情况下则不进行任何的操作，而如果是阻塞的，才用IO多路复用poll进行检测？？

int redisContextConnectTcp(redisContext *c, const char *addr, int port, struct timeval *timeout) {
    int s, rv;
    char _port[6];  /* strlen("65535"); */
    struct addrinfo hints, *servinfo, *p;
    int blocking = (c->flags & REDIS_BLOCK);  // 保存redis上下文是否是阻塞
    snprintf(_port, 6, "%d", port);
    memset(&hints,0,sizeof(hints));
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    /* Try with IPv6 if no IPv4 address was found. We do it in this order since
     * in a Redis client you can't afford to test if you have IPv6 connectivity
     * as this would add latency to every connect. Otherwise a more sensible
     * route could be: Use IPv6 if both addresses are available and there is IPv6
     * connectivity. */
    if ((rv = getaddrinfo(addr,_port,&hints,&servinfo)) != 0) {
        hints.ai_family = AF_INET6;
        if ((rv = getaddrinfo(addr,_port,&hints,&servinfo)) != 0) {
            __redisSetError(c,REDIS_ERR_OTHER,gai_strerror(rv));
            return REDIS_ERR;
        }
    }
    for (p = servinfo; p != NULL; p = p->ai_next) {
        if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1)
            continue;
        // 设置成非阻塞
        if (redisSetBlocking(c,s,0) != REDIS_OK)
            goto error;
        // 如果连接发成错误信息，返回-1，成功返回0
        if (connect(s,p->ai_addr,p->ai_addrlen) == -1) {
            if (errno == EHOSTUNREACH) {   // 远程地址无法到达
                close(s);
                continue;
            } else if (errno == EINPROGRESS && !blocking) {
                /* This is ok. */
                // 如果之前套接字是非阻塞，并且返回正在连接则连接建立已经启动，但是还没完成
                // 这种情况发生在redis环境是非阻塞的状态下
            } else {
                // 如果redis上下文是阻塞的，在设置成非阻塞后进行接下来的IO多路复用操作
                if (redisContextWaitReady(c,s,timeout) != REDIS_OK)
                    goto error;
            }
        }
        // 如果之前是阻塞则设置回阻塞
        if (blocking && redisSetBlocking(c,s,1) != REDIS_OK)
            goto error;
        // 设置没有延迟
        if (redisSetTcpNoDelay(c,s) != REDIS_OK)
            goto error;
        c->fd = s;
        c->flags |= REDIS_CONNECTED; // 设置状态为已连接
        rv = REDIS_OK;
        goto end;
    }
    if (p == NULL) {
        char buf[128];
        snprintf(buf,sizeof(buf),"Can't create socket: %s",strerror(errno));
        __redisSetError(c,REDIS_ERR_OTHER,buf);
        goto error;
    }
    error:
    rv = REDIS_ERR;
    end:
    freeaddrinfo(servinfo);
    return rv;  // Need to return REDIS_OK if alright
}

使用poll进行检测，和select的作用是一样的，Redis可能考虑到单个进程打开的套接字限制才改用的poll：

static int redisContextWaitReady(redisContext *c, int fd, const struct timeval *timeout) {
    struct pollfd   wfd[1];
    long msec;
    msec          = -1;
    wfd[0].fd     = fd;
    wfd[0].events = POLLOUT;
    /* Only use timeout when not NULL. */
    if (timeout != NULL) {
        if (timeout->tv_usec > 1000000 || timeout->tv_sec > __MAX_MSEC) {
            close(fd);
            return REDIS_ERR;
        }
        msec = (timeout->tv_sec * 1000) + ((timeout->tv_usec + 999) / 1000);
        if (msec < 0 || msec > INT_MAX) {
            msec = INT_MAX;
        }
    }
    if (errno == EINPROGRESS) {
        int res;
        if ((res = poll(wfd, 1, msec)) == -1) {
            __redisSetErrorFromErrno(c, REDIS_ERR_IO, "poll(2)");
            close(fd);
            return REDIS_ERR;
        } else if (res == 0) {
            errno = ETIMEDOUT;
            __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
            close(fd);
            return REDIS_ERR;
        }
        if (redisCheckSocketError(c, fd) != REDIS_OK)
            return REDIS_ERR;
        return REDIS_OK;
    }
    __redisSetErrorFromErrno(c,REDIS_ERR_IO,NULL);
    close(fd);
    return REDIS_ERR;
}

参考

1. Socket编程之非阻塞connect
2. Redis github