Question

我正在研究接受传入TCP连接的软件，并且遇到了一些我不理解的东西。首先，我将解释软件基本上在做什么。请记住，有些部分是暂时的，我知道这很可能是一种糟糕的做事方式，但在原型设计过程中，我遇到了这个问题。

我有主进程为SIGINT建立信号处理程序。然后主进程启动一个新线程，将其称为'listener'，使用pthread_create（）默认值。侦听器首先打开套接字，绑定，侦听并设置套接字非阻塞。然后，侦听器将使用select（）轮询套接字，等待传入连接。

现在，如果我在主线程中有一个哑的while（1）循环，我可以毫无问题地连接到套接字。问题是：如果我用pause（）替换while（1）循环，我就不能再连接到套接字了。我知道监听器线程仍然通过日志消息激活。同样，我不打算使用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))

在main.c：

    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 X上的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");
    }
}

kill -SIGINT“pid”和kill -SIGTERM“pid”被使用。

暂停阻塞的套接字（）

2 个答案: