应用程序是否可以处理 N 个 accept 连接并且每个 accept 使用独立的线程

Question

我有 C linux TCP 客户端/服务器应用程序。我想出了一个奇怪的场景，但我不知道这个应用程序是否有任何后果。我有一个可以接受 N 个连接的服务器端，例如这个服务器将接受 100 个连接。在这种情况下，我在主线程中创建监听套接字，然后创建 100 个线程，每个线程都有一个独立的 accept() 和一个 select() iomux，而且每个线程只能接受一个连接。

我在这里担心，如果两个同时接受()想要接受同一个套接字(连接)，因为选择是准备在同一个套接字上读取，我不知道同时接受在内核中是否是线程安全的并且只有一个 accept 可以处理传入的连接，而另一个将等待另一个连接？

我在我的 RedHat 机器上试过它运行良好，但我不知道我是否幸运地避免了死锁!

谢谢

rc = bind(sd, (struct sockaddr_in *)& groupSock, sizeof(struct sockaddr_in));
    CHECK_VALUE("Bind address error", rc, 0, goto cleanup);

    rc = listen(sd, 10);
    CHECK_VALUE("listen", rc, 0, goto cleanup);

    for(; count< num_socks; count++){

            par_data[count].sd = sd;
            par_data[count].thread_num = count;
            par_data[count].err_chk = -1;

            rc = pthread_create(&thread_id[count], NULL, accept_sock_thread,  (void *)& par_data[count]);
            CHECK_VALUE("pthread_create", rc, 0, goto cleanup);


    }

void * accept_sock_thread(void* atr){

    int                     rc;
    int                     sock            = INVALID_SOCKET;
    int                     datalen         = config.traffic;
    char                    *databuf        = NULL;
    struct thread_data      *data           = NULL;
    struct sockaddr_in      tcp_remote;
    struct timeval          t;
    socklen_t               size;
    fd_set                  socks;

    databuf = malloc(sizeof(char) * datalen);
    memset(databuf, 0, datalen);

    data = (struct thread_data*) atr;
    DEBUG(my_debug_flags, ENTER_FUNCT, ("Enter Function accept_sock_thread thread_num %d \n", data->thread_num));


    FD_ZERO(&socks);
    FD_SET(data->sd, &socks);
    t.tv_sec = 25;
    t.tv_usec = 0;
    rc = select(data->sd + 1 , &socks, NULL, NULL,&t);
    if(rc < 0){
            VL_MISC_ERR(("Error in select with Errno: %d", errno));
            goto cleanup;
    }
    else if(rc == 0){
            VL_MISC_ERR(("Accept Select returned a TIEMOUT."));
            goto cleanup;
    }


    size = sizeof(struct sockaddr_in);
    sock = accept(data->sd, (struct sockaddr *)& tcp_remote, &size);
    CHECK_NOT_EQUAL("tcp accept error", sock, INVALID_SOCKET,  goto cleanup);
cleanup:
    //      sleep(2); /* avoid EOF */
    if(sock != INVALID_SOCKET){

            rc = close(sock);
            if(rc != 0){
                    data->err_chk = -1;
            }
    }
           return NULL;
}

Answer 1

accept() 根据 POSIX 是线程安全和可重入的。

这意味着对同一个描述符的两次 accept 调用不应该给出未定义的行为。其中一个接受将打开套接字，另一个将返回错误。

你可以在那里看到更多:

Is accept() thread-safe? Are BSD/Posix sockets reentrant?