8

我想在 C/Linux 中开发一个多线程 UDP 服务器。该服务在单个端口 x 上运行，因此只能将单个 UDP 套接字绑定到它。为了在高负载下工作，我有 n 个线程（静态定义），比如每个 CPU 1 个线程。可以使用 epoll_wait 将工作交付给线程，因此可以使用 'EPOLLET | 按需唤醒线程。埃波罗内肖特”。我附上了一个代码示例：

static int epfd;
static sig_atomic_t sigint = 0;

...

/* Thread routine with epoll_wait */
static void *process_clients(void *pevents)
{
    int rc, i, sock, nfds;
    struct epoll_event ep, *events = (struct epoll_event *) pevents;

    while (!sigint) {
        nfds = epoll_wait(epfd, events, MAX_EVENT_NUM, 500);

        for (i = 0; i < nfds; ++i) {
           if (events[i].data.fd < 0)
                continue;

           sock = events[i].data.fd;

           if((events[i].events & EPOLLIN) == EPOLLIN) {
               printf("Event dispatch!\n");
               handle_request(sock); // do a recvfrom
           } else
               whine("Unknown poll event!\n");

           memset(&ep, 0, sizeof(ep));
           ep.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
           ep.data.fd = sock;

           rc = epoll_ctl(epfd, EPOLL_CTL_MOD, sock, &ep);
           if(rc < 0)
               error_and_die(EXIT_FAILURE, "Cannot add socket to epoll!\n");
       }
    }

    pthread_exit(NULL);
}

int main(int argc, char **argv)
{
    int rc, i, cpu, sock, opts;
    struct sockaddr_in sin;
    struct epoll_event ep, *events;
    char *local_addr = "192.168.1.108";
    void *status;
    pthread_t *threads = NULL;
    cpu_set_t cpuset;

    threads = xzmalloc(sizeof(*threads) * MAX_THRD_NUM);
    events = xzmalloc(sizeof(*events) * MAX_EVENT_NUM);

    sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (sock < 0)
        error_and_die(EXIT_FAILURE, "Cannot create socket!\n");

    /* Non-blocking */
    opts = fcntl(sock, F_GETFL);
    if(opts < 0)
        error_and_die(EXIT_FAILURE, "Cannot fetch sock opts!\n");
    opts |= O_NONBLOCK;
    rc = fcntl(sock, F_SETFL, opts);
    if(rc < 0)
        error_and_die(EXIT_FAILURE, "Cannot set sock opts!\n");

    /* Initial epoll setup */
    epfd = epoll_create(MAX_EVENT_NUM);
    if(epfd < 0)
        error_and_die(EXIT_FAILURE, "Error fetching an epoll descriptor!\n");

    memset(&ep, 0, sizeof(ep));
    ep.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
    ep.data.fd = sock;

    rc = epoll_ctl(epfd, EPOLL_CTL_ADD, sock, &ep);
    if(rc < 0)
        error_and_die(EXIT_FAILURE, "Cannot add socket to epoll!\n");

    /* Socket binding */
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = inet_addr(local_addr);
    sin.sin_port = htons(port_xy);

    rc = bind(sock, (struct sockaddr *) &sin, sizeof(sin));
    if (rc < 0)
        error_and_die(EXIT_FAILURE, "Problem binding to port! "
                      "Already in use?\n");

    register_signal(SIGINT, &signal_handler);

    /* Thread initialization */
    for (i = 0, cpu = 0; i < MAX_THRD_NUM; ++i) {
        rc = pthread_create(&threads[i], NULL, process_clients, events);
        if (rc != 0)
            error_and_die(EXIT_FAILURE, "Cannot create pthread!\n");

        CPU_ZERO(&cpuset);
        CPU_SET(cpu, &cpuset);

        rc = pthread_setaffinity_np(threads[i], sizeof(cpuset), &cpuset);
        if (rc != 0)
            error_and_die(EXIT_FAILURE, "Cannot create pthread!\n");

        cpu = (cpu + 1) % NR_CPUS_ON;
    }

    printf("up and running!\n");

    /* Thread joining */
    for (i = 0; i < MAX_THRD_NUM; ++i) {
        rc = pthread_join(threads[i], &status);
        if (rc != 0)
            error_and_die(EXIT_FAILURE, "Error on thread exit!\n");
    }

    close(sock);
    xfree(threads);
    xfree(events);

    printf("shut down!\n");

    return 0;
}

这是用 epoll 处理这种情况的正确方法吗？函数 _handle_request_ 是否应该尽快返回，因为此时套接字的事件队列被阻塞了？

感谢您的回复！

4

2 回答 2

8

由于您只使用单个 UDP 套接字，因此使用 epoll 没有意义 - 只需使用阻塞的 recvfrom 代替。

现在，根据您需要处理的协议 - 如果您可以单独处理每个 UDP 数据包 - 您实际上可以从多个线程（在线程池中）同时调用 recvfrom 。操作系统会确保只有一个线程会接收到 UDP 数据包。然后这个线程可以在handle_request 中做它需要做的任何事情。

但是，如果您需要以特定顺序处理 UDP 数据包，您可能没有那么多机会来并行化您的程序......

于 2010-10-18T19:36:28.440 回答
-1

不，这不会按照您想要的方式工作。要让工作线程处理通过 epoll 接口到达的事件，您需要不同的架构。

示例设计（有几种方法可以做到这一点） 用途：SysV/POSIX 信号量。

  • 让主线程产生 n 个子线程和一个信号量，然后阻止 epolling 你的套接字（或其他）。

  • 让每个子线程阻塞信号量。

  • 当主线程解除阻塞时，它将事件存储在某个全局结构中，并为每个事件增加一次信号量。

  • 子线程解除阻塞，处理事件，当信号量返回 0 时再次阻塞。

您可以使用在所有线程之间共享的管道来实现与信号量非常相似的功能。这会让你阻塞select()而不是信号量，你可以用它来唤醒线程在一些其他事件（超时、其他管道等）上。

您还可以反转此控制，并在其工作人员需要任务时唤醒主线程。不过，我认为上述方法更适合您的情况。

于 2010-10-18T16:14:41.610 回答