中断线程内的选择、睡眠和类似的阻塞功能（pthread）。线程中的信号

Question

我有一个接受连接的服务器套接字线程。它使用超时1秒的选择来做其他事情。然而，有时我想在特定信号从外部到达应用程序时立即做这些事情。在单线程程序中，信号会中断睡眠和定时IO阻塞功能，如选择。然而，在主信号以外的线程中，不会中断睡眠。

我可以使用pthread_kill（）从主线程发出信号，并且睡眠被中断，但是当信号来自外部时，它不会中断线程中的睡眠。如果我安装一个处理程序，并在处理程序内部调用pthread_kill（），处理程序将捕获信号并进入无限循环。

如何通过程序外部的信号中断睡眠？例如SIGUSR1。

我可以这样做:我可以启动另一个线程来做我在服务器线程中做的其他事情。它会等待一个条件，然后主线程会向等待线程发送一个信号。但是我真的想知道如何中断其他线程的睡眠/选择——例如，为了更快地关机，我想中断所有等待，让线程更快地退出。我还想了解信号在其他线程中是如何工作的。有时你想中断一个不在你的代码中的睡眠(另一个库)

我读到了pthread_sigmask()，但我不确定我理解了它。在主线程中，安装了处理程序来处理信号。其他线程中会发生什么？这个例子使用sigwait()来接收信号。如果不调用sigwait会怎么样？信号是累积在一个队列中，还是它们对不等待它们的线程没有影响？

Answer 1

这是我想到的。我不知道是否有其他解决方案。我会等待建议。

为了发出需要完成工作的信号，SIGUSR1被发送到程序。它向线程发送SIGALERT，使它们中断阻塞代码，如sleep、select等。作为副作用，主线程中的阻塞也会被中断，即使信号只发送给其他线程。

它不能只用一个信号来完成 - 就像处理sigalert然后使用pthread_kill信号提醒其他两个线程一样，因为它进入了一个无限循环。

#include <stdio.h>
#include <stdlib.h> // EXIT_FAILURE
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <errno.h> // for errno
#include <pthread.h>

#ifndef __cplusplus
#define true 1
#define false 0
#define nullptr NULL
typedef int bool;
#endif

// I copied this. I don't know why it's in a loop
#define handle_error_en(en, msg) \
        do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

pthread_t t1;
pthread_t t2;
pthread_t st;
pthread_t mainThreadId; // main thread

void *workerThread(void * param);
void unblockSignals();
void alertSignaHlandler(int sigNum);
void installSignalHandler(int sigNum, __sighandler_t handler);

void sigUsr1Handler(int sigNum) {
  pthread_kill(t1, SIGALRM);
//  pthread_kill(t2, SIGALRM); // let's say we only want t1 to interrupt
}

// on SIGTERM we want all threads to interrupt sleep so they can quit faster
void sigTermHandler(int sigNum) {
  // setRunning(false); // also implement a global running vairable with a mutex, that other threads check to quit
  pthread_kill(t1, SIGALRM);
  pthread_kill(t2, SIGALRM);
//  pthread_kill(mainThreadId, SIGALRM); // main thread will be interrupted by the signal anyway.
}

void alertSignaHlandler(int sigNum) {}

int main() {
  void * ret1;
  void * ret2;

  mainThreadId = pthread_self();

  printf("main starting with pid %d\n", getpid());

  installSignalHandler(SIGALRM, alertSignaHlandler); // we need this to prevent program termination on alarm
  installSignalHandler(SIGUSR1, sigUsr1Handler); // send this signal to interrupt other threads
  installSignalHandler(SIGTERM, sigTermHandler);
  installSignalHandler(SIGINT, sigTermHandler);

  pthread_create(&t1, NULL, &workerThread, (void *)1);
  pthread_create(&t2, NULL, &workerThread, (void *)2);

  // simulate work in main thread. Only interrupt this on SIGTERM or SIGINT (ctrl-c)
  time_t ts = time(NULL);
  sleep(20);
  ts = time(NULL) - ts;
  printf("main(): sleep took %lds\n", ts);


  pthread_join(t1, &ret1);
  pthread_join(t2, &ret2);

  printf("main thread reached end\n");

  return 0;
}

void *workerThread(void * param){
  long id = (long) param;

  printf("workerThread %d starting...\n", id);

  // in the real world this will be in a loop. somethign like this
  //  while(running) {
  //    // do something every minute
  //    doSomething();
  //    sleep(60); // this sleep we want to interrupt, because we don't want to wait 60 seconds to exit
  //  }

  time_t ts = time(NULL);
  sleep(60); // this can also be select, read or other timed blocking call.
  ts = time(NULL) - ts;
  printf("workerThread(%ld): sleep took %lds\n", id, ts);

  return NULL;
}

void installSignalHandler(int sigNum, __sighandler_t handler){
  struct sigaction newAction, oldAction;

  memset(&newAction, '\0', sizeof(newAction));
  newAction.sa_flags = 0;
  //newAction.sa_flags = SA_RESETHAND;
  newAction.sa_handler = handler;
  sigaction(sigNum, &newAction, &oldAction);
}