套接字被pause()阻塞

Question

我正在开发一种软件，可以接受传入的TCP连接，并且遇到了一些我不理解的东西。首先，我将解释软件的基本功能。请记住，其中一些部分是暂时的，我知道这很可能是一种糟糕的处理方法，但是在原型化过程中，我遇到了这个问题。

我有主进程为SIGINT建立一个信号处理程序。然后，主进程启动一个新线程，称为“监听器”，默认设置为pthread_create()。侦听器首先打开套接字、绑定、侦听和设置套接字非阻塞。然后，侦听器将使用select()轮询套接字，等待传入的连接。

现在，如果我在主线程中有一个哑巴while(1)循环，我就可以连接到套接字，而不会出现问题。问题是:如果用pause()替换while(1)循环，则无法再连接到套接字。我知道侦听器线程仍然通过日志消息处于活动状态。同样，我不打算使用pause()，但我只想知道到底发生了什么。

pause()是否阻止某个信号到达子线程？

更新:我提供的简化代码似乎没有表现出相同的行为。如果我能确定原因，我会再次更新。

UPDATE2:，我解决了这个问题。在我发布的代码和我的问题代码之间有一个关键的区别。以下是不同之处：

static void* listener_thread(void* arg)
{
    int listen_port = *(int *)arg;
    int listen_fd;
    fd_set readSet;
    int fdsMax, status;
    struct timeval timeout;

    if(open_listen_port(listen_port, &listen_fd) == -1)

..。

int start_listener_thread(int port)
{
    int status = 0;

    if(0 > pthread_create(&thread_id, NULL, listener_thread, (void *)&port))

在主要方面：

    if(0 == status && -1 == start_listener_thread(3000))

因此，您可以看到，我将端口号作为指向堆栈位置的指针传递给线程。不是个好主意。奇怪的是，如果我将pause()更改为while(1)循环，它就会工作。对于pause()，端口号恰好是一个有效的端口。

在start_listener_thread中为端口号分配空间解决了这个问题。谢谢你在路上的帮助！

代码示例(删减)：

#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/select.h>
#include <unistd.h>

pthread_t thread_id;

void sighandler(int signum)
{
}

int open_listen_port(int listenPort, int* listenFd)
{
    struct sockaddr_in listenAddr;
    int flags;

    memset(&listenAddr, 0, sizeof(listenAddr));
    listenAddr.sin_family = AF_INET;
    listenAddr.sin_port = htons(listenPort);
    listenAddr.sin_addr.s_addr = INADDR_ANY;

    if( (*listenFd = socket(AF_INET, SOCK_STREAM, 0)) == -1 )
    {
        return(-1);
    }

    if( bind(*listenFd, (struct sockaddr*) &listenAddr,
        sizeof(listenAddr)) == -1 )
    {
        return(-1);
    }

    if( listen(*listenFd, 16) == -1 )
    {
        return(-1);
    }

    // change listener to be non-blocking
    flags = fcntl(*listenFd, F_GETFL);
    if(fcntl(*listenFd, F_SETFL, flags | O_NONBLOCK) == -1)
    {
        return(-1);
    }

    return (0);
}

static void* listener_thread(void* arg)
{
    int listen_fd;
    fd_set readSet;
    int fdsMax, status;
    struct timeval timeout;

    if(open_listen_port(3000, &listen_fd) == -1)
    {
        pthread_exit(NULL);
    }

    while(1)
    {
        FD_ZERO(&readSet);
        fdsMax = 0;
        timeout.tv_sec = 0;
        timeout.tv_usec = 500000;

        FD_SET(listen_fd, &readSet);
        if(listen_fd > fdsMax)
        {
            fdsMax = listen_fd;
        }

        status = select(fdsMax + 1, &readSet, NULL, NULL, &timeout);
    }
    return NULL;
}

int start_listener_thread()
{
    int status = 0;

    if(0 > pthread_create(&thread_id, NULL, listener_thread, NULL))
    {
        status = -1;
    }

    return(status);
}

int main(int argc, char *argv[])
{
    struct sigaction sigopt;
    int status = 0;

    memset(&sigopt, 0, sizeof(struct sigaction));
    sigopt.sa_handler = sighandler;
    if(0 != sigaction(SIGINT, &sigopt, NULL))
    {
        status = -1;
    }

    if(0 == status && -1 == start_listener_thread())
    {
        status = -1;
    }

    pause();

    return(0);
}

Answer 1

来自OS上的man pause：

DESCRIPTION
 Pause is made obsolete by sigsuspend(2).

 The pause() function forces a process to pause until a signal is received
 from either the kill(2) function or an interval timer.  (See
 setitimer(2).)  Upon termination of a signal handler started during a
 pause(), the pause() call will return.

来自Linux上的man pause：

DESCRIPTION
 pause()  causes the calling process (or thread) to sleep until a signal
 is delivered that either terminates the process or causes  the  invoca‐
 tion of a signal-catching function.

这两个手动页面都意味着调用过程将处于休眠状态。这解释了为什么不能打电话给accept()。

您能确定是否正在调用accept()吗？您是否在适当情况下检查所有返回状态和errno？

我不知道睡觉线的目的是什么。如果您必须使主线程保持活动状态，为什么不使用类似于sleep()调用的while循环呢？(也许您打算添加代码，以便稍后在这里轮询一些内容？在这种情况下，使用usleep()和您想要检查的间隔，或者sleep(1) (如果每秒一次粒度就足够了)？)或者只是在主线程上运行您的select()。

编辑：，在我看来，这个程序正在运行。我将其修改如下：

--- /tmp/foo.c  2014-02-11 16:43:04.000000000 -0800
+++ /tmp/foo.c  2014-02-11 16:46:17.000000000 -0800
@@ -7,6 +7,7 @@
 #include <signal.h>
 #include <sys/select.h>
 #include <unistd.h>
+#include <stdio.h>

 pthread_t thread_id;

@@ -76,6 +77,7 @@
         }

         status = select(fdsMax + 1, &readSet, NULL, NULL, &timeout);
+        printf("select() woke up\n");
     }
     return NULL;
 }

当我进行上述更改时，它每隔半秒钟打印一次select() woke up，直到连接到套接字为止。然后它反复打印出来。

你能更好地描述你所看到的行为吗？是否有阻止的调用，如对套接字的读或写？

您能附加(或在内部运行) gdb并找出每个线程正在做什么吗？

Answer 2

下面的程序显示，当主线程暂停时，线程继续运行。再加上Mike's无法在两个不同的平台上重现您的问题，我认为让您重新确认您确实看到了上面描述的内容是公平的。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

#define exitOnErr(msg) do { perror(msg); exit(EXIT_FAILURE); } while (0)

static void handler(int sig)
{
    printf("don't use printf in a signal handler\n");
}

void *athread(void* x)
{
    while (1)
    {
        printf("thread running\n");
        sleep(1);
    }
}

int main(int argc, char *argv[])
{
    printf("%d\n", getpid());

    pthread_t pid;

    if (signal(SIGINT, handler) == SIG_ERR)
        exitOnErr("signal");

    if(pthread_create(&pid, NULL, athread, NULL) != 0)
        exitOnErr("pthread_create");

    while(1)
    {
        pause();
        printf("pause returned\n");
    }
}

采用杀灭-SIGINT "pid“和杀死-SIGTERM "pid”的方法。