为什么在epoll中推荐NON-BLOCKING sockets

Question

我正在尝试学习如何将 epoll() 用于 tcp 服务器应用程序，因为我期待很多连接。 我试着检查示例和教程，他们总是建议使用/设置 sockets 添加到 epoll() 中的是非阻塞 sockets。为什么？

Answer 1

使用传统的阻塞I / O，每个连接必须由一个或多个专用线程处理。 随着连接数量的增加，所需线程的数量也会增加。 这个模型在连接数量达到数百或数千的情况下工作得相当好，但它不能很好地扩展。

多路复用和非阻塞I / O反转模型，允许一个线程为许多不同的连接提供服务。 它通过同时监视所有活动连接并且仅在套接字准备就绪时执行I / O来实现（例如，数据已到达，这意味着至少可以执行一次读取而不会阻塞）。

这是一个更具可扩展性的解决方案，因为现在你没有成群的大多数非活动线程坐在他们的拇指周围。 相反，你有一个或几个非常活跃的线程在所有套接字之间穿梭。

Answer 2

对于级别触发的 epoll，非阻塞套接字可以帮助最小化 epoll_wait() 调用，这是一个优化问题。

对于边缘触发的 epoll，您必须使用非阻塞套接字并调用 read() 或 write() 直到它们返回 EWOULDBLOCK。 如果不这样做，您可能会错过内核通知。

你可以在这里找到详细的答案： https : //eklitzke.org/blocking-io-nonblocking-io-and-epoll

Answer 3

这是一个很好的问题，没有重复。 最近也在select （ select是level-triggered only）找到一个使用nonblocking socket的教程，引发思考。

问题是：

为什么在级别触发的epoll 、 select或其他类似接口中使用非阻塞 IO 或将fd设置为非闪烁？

这个案子其实有非常充分的理由。

引用本书The Linux Programming Interface ：

63.1.2 使用替代 I/O 模型的非阻塞 I/O

非阻塞 I/O（ O_NONBLOCK标志）通常与本章描述的 I/O 模型结合使用。 为什么这可能有用的一些示例如下：

• 如前一节所述，非阻塞 I/O 通常与提供边缘触发 I/O 事件通知的 I/O 模型结合使用。
• 如果多个进程（或线程）正在对同一个打开的文件描述执行 I/O，那么，从特定进程的角度来看，描述符的就绪状态可能会在描述符被通知准备就绪的时间和后续通知的时间之间发生变化输入/输出调用。 因此，阻塞 I/O 调用可能会阻塞，从而阻止进程监视其他文件描述符。 （这可能发生在我们在本章中描述的所有 I/O 模型中，无论它们使用电平触发通知还是边沿触发通知。）
• 即使在级别触发的 API（例如select()或poll()通知我们 stream 套接字的文件描述符已准备好写入之后，如果我们在单个write()或send()中写入足够大的数据块，那么调用仍然会阻塞。
• 在极少数情况下，诸如select()和poll()之类的级别触发的 API 会返回虚假的就绪通知——它们会错误地通知我们文件描述符已就绪。 这可能是由 kernel 错误引起的，也可能是罕见情况下的预期行为。

首先，让我们检查案例 #2： “如果多个进程（或线程）正在对相同的打开文件描述执行 I/O...” 。

从libevent介绍中阅读这段代码， http://www.wangafu.net/~nickm/libevent-book/01_intro.html 。

/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For fcntl */
#include <fcntl.h>
/* for select */
#include <sys/select.h>

#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#define MAX_LINE 16384

char
rot13_char(char c)
{
    /* We don't want to use isalpha here; setting the locale would change
     * which characters are considered alphabetical. */
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

struct fd_state {
    char buffer[MAX_LINE];
    size_t buffer_used;

    int writing;
    size_t n_written;
    size_t write_upto;
};

struct fd_state *
alloc_fd_state(void)
{
    struct fd_state *state = malloc(sizeof(struct fd_state));
    if (!state)
        return NULL;
    state->buffer_used = state->n_written = state->writing =
        state->write_upto = 0;
    return state;
}

void
free_fd_state(struct fd_state *state)
{
    free(state);
}

void
make_nonblocking(int fd)
{
    fcntl(fd, F_SETFL, O_NONBLOCK);
}

int
do_read(int fd, struct fd_state *state)
{
    char buf[1024];
    int i;
    ssize_t result;
    while (1) {
        result = recv(fd, buf, sizeof(buf), 0);
        if (result <= 0)
            break;

        for (i=0; i < result; ++i)  {
            if (state->buffer_used < sizeof(state->buffer))
                state->buffer[state->buffer_used++] = rot13_char(buf[i]);
            if (buf[i] == '\n') {
                state->writing = 1;
                state->write_upto = state->buffer_used;
            }
        }
    }

    if (result == 0) {
        return 1;
    } else if (result < 0) {
        if (errno == EAGAIN)
            return 0;
        return -1;
    }

    return 0;
}

int
do_write(int fd, struct fd_state *state)
{
    while (state->n_written < state->write_upto) {
        ssize_t result = send(fd, state->buffer + state->n_written,
                              state->write_upto - state->n_written, 0);
        if (result < 0) {
            if (errno == EAGAIN)
                return 0;
            return -1;
        }
        assert(result != 0);

        state->n_written += result;
    }

    if (state->n_written == state->buffer_used)
        state->n_written = state->write_upto = state->buffer_used = 0;

    state->writing = 0;

    return 0;
}

void
run(void)
{
    int listener;
    struct fd_state *state[FD_SETSIZE];
    struct sockaddr_in sin;
    int i, maxfd;
    fd_set readset, writeset, exset;

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(40713);

    for (i = 0; i < FD_SETSIZE; ++i)
        state[i] = NULL;

    listener = socket(AF_INET, SOCK_STREAM, 0);
    make_nonblocking(listener);

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        perror("bind");
        return;
    }

    if (listen(listener, 16)<0) {
        perror("listen");
        return;
    }

    FD_ZERO(&readset);
    FD_ZERO(&writeset);
    FD_ZERO(&exset);

    while (1) {
        maxfd = listener;

        FD_ZERO(&readset);
        FD_ZERO(&writeset);
        FD_ZERO(&exset);

        FD_SET(listener, &readset);

        for (i=0; i < FD_SETSIZE; ++i) {
            if (state[i]) {
                if (i > maxfd)
                    maxfd = i;
                FD_SET(i, &readset);
                if (state[i]->writing) {
                    FD_SET(i, &writeset);
                }
            }
        }

        if (select(maxfd+1, &readset, &writeset, &exset, NULL) < 0) {
            perror("select");
            return;
        }

        if (FD_ISSET(listener, &readset)) {
            struct sockaddr_storage ss;
            socklen_t slen = sizeof(ss);
            int fd = accept(listener, (struct sockaddr*)&ss, &slen);
            if (fd < 0) {
                perror("accept");
            } else if (fd > FD_SETSIZE) {
                close(fd);
            } else {
                make_nonblocking(fd);
                state[fd] = alloc_fd_state();
                assert(state[fd]);/*XXX*/
            }
        }

        for (i=0; i < maxfd+1; ++i) {
            int r = 0;
            if (i == listener)
                continue;

            if (FD_ISSET(i, &readset)) {
                r = do_read(i, state[i]);
            }
            if (r == 0 && FD_ISSET(i, &writeset)) {
                r = do_write(i, state[i]);
            }
            if (r) {
                free_fd_state(state[i]);
                state[i] = NULL;
                close(i);
            }
        }
    }
}

int
main(int c, char **v)
{
    setvbuf(stdout, NULL, _IONBF, 0);

    run();
    return 0;
}

这不是多个进程（或线程）对相同的打开文件描述执行 I/O 的示例，但它演示了相同的想法。

在do_read function 中，它在 side a while(1)中使用recv来读取尽可能多的字节，但每个recv读取1024个字节。 我想这是一个典型的模式。

所以这里需要非阻塞，否则recv最终会在没有数据in.network输入的时候阻塞。

对于#3，如果您在阻塞套接字中写入过多数据并且没有足够的缓冲区。 send将阻塞，直到发送完所有数据。 如果发送缓冲区中没有足够的空间，它可能会阻塞足够长的时间。 更多详情请查看https://stackoverflow.com/a/74172742/5983841 。