将信号定位到 C 中的特定线程

Question

我们在我们的进程中使用 posix 间隔计时器（使用 timer_create() 创建）在计时器到期时生成 SIGALRM。 生成的信号由进程中的特定线程异步处理（sigwait），我们已使用 sig_block 阻止了所有其他线程中的信号。 'Sig_block' 在子线程产生之前在主线程中调用，因此子线程从父线程（即主线程）继承它。 然而，这有一个警告，如果进程中包含的任何库在 dllmain 期间产生任何线程，则信号不会在该线程中被阻塞。 此外，我们无法控制包含在流程中的 DLL 的内部实现。 你能建议如何处理这个问题吗？ 有没有其他方法可以将计时器到期信号定位到进程中的特定线程？

我检查了选项“SIGEV_THREAD_ID”。 但是文档声明它仅供线程库使用。

Answer 1

如果您不介意特定于 Linux，请使用SIGEV_THREAD_ID 。 另外，我建议使用实时信号（ SIGRTMIN+0到SIGRTMAX-0 ，包括在内），因为这些信号是按发送顺序排队和交付的。

SIGEV_THREAD_ID被记录为仅供线程库使用的原因是 Linux 线程 ID 通常不公开； 此接口不能直接用于 pthreads 等。 您将需要实现自己的gettid() ：

#define  _GNU_SOURCE
#include <unistd.h>
#include <sys/types.h>
#include <sys/syscall.h>

static inline pid_t gettid(void) { return syscall(SYS_gettid); }

这将依赖于 Linux pthreads 不会做任何愚蠢的事情，比如在保持相同 pthread_t ID 的同时切换线程 ID。

就个人而言，我建议采用不同的方法，使用辅助线程来维护超时。

让线程维护与目标线程 ID ( pthread_t ) 关联的已排序数组或超时时间戳的二进制堆。 线程将在pthread_cond_timedwait()中等待，直到下一次超时到期，或者发出信号，表明超时已更改（取消或添加了新的）。 当一个或多个超时到期时，线程使用pthread_sigqueue()将适当的信号发送到目标线程，并将超时标识符作为有效负载。

也许一个粗略的简化草图有助于理解。 为简单起见，假设挂起的超时形成一个单链表：

struct timeout {
    struct timeout  *next;
    struct timespec  when;    /* Absolute CLOCK_REALTIME time */
    double           repeat;  /* Refire time in seconds, 0 if single-shot */
    pthread_id       thread;
    int              elapsed;
};

pthread_mutex_t      timeout_lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t       timeout_wait = PTHREAD_COND_INITIALIZER;
struct timeout      *timeout_pending = NULL;
int                  timeout_quit = 0;

static inline int timespec_cmp(const struct timespec t1, const struct timespec t2)
{
    return (t1.tv_sec < t2.tv_sec) ? -1 :
           (t1.tv_sec > t2.tv_sec) ? +1 :
           (t1.tv_nsec < t2.tv_nsec) ? -1 :
           (t1.tv_nsec > t2.tv_nsec) ? +1 : 0;
}

static inline void timespec_add(struct timespec *const ts, const double seconds)
{
    if (seconds > 0.0) {
        ts->tv_sec += (long)seconds;
        ts->tv_nsec += (long)(1000000000.0*(double)(seconds - (long)seconds));
        if (ts->tv_nsec < 0)
            ts->tv_nsec = 0;
        if (ts->tv_nsec >= 1000000000) {
            ts->tv_sec += ts->tv_nsec / 1000000000;
            ts->tv_nsec = ts->tv_nsec % 1000000000;
        }
    }
}

struct timeout *timeout_arm(double seconds, double repeat)
{
    struct timeout *mark;

    mark = malloc(sizeof (timeout));
    if (!mark) {
        errno = ENOMEM;
        return NULL;
    }

    mark->thread = pthread_self();
    mark->elapsed = 0;
    clock_gettime(CLOCK_REALTIME, &(mark->when));
    timespec_add(&(mark->when), seconds);
    mark->repeat = repeat;

    pthread_mutex_lock(&timeout_lock);

    mark->next = timeout_pending;
    timeout_pending = mark;

    pthread_cond_signal(&timeout_wait);
    pthread_mutex_unlock(&timeout_lock);

    return mark;

对timeout_arm()的调用会返回一个指向超时的指针作为标识符，以便线程稍后可以解除它：

int timeout_disarm(struct timeout *mark)
{
    int  result = -1;

    pthread_mutex_lock(&timeout_lock);

    if (timeout_pending == mark) {
        timeout_pending = mark->next;
        mark->next = NULL;
        result = mark->elapsed;
    } else {
        struct timeout  *list = timeout_pending;
        for (; list->next != NULL; list = list->next) {
            if (list->next == mark) {
                list->next = mark->next;
                mark->next = NULL;
                result = mark->elapsed;
                break;
            }
        }
    }

    /* if (result != -1) free(mark); */

    pthread_mutex_unlock(&timeout_lock);
    return result;
}

注意上面的 function 并没有free()超时结构（除非你取消注释接近末尾的行），如果找不到超时它返回-1 ，如果成功则删除超时时的elapsed字段.

管理超时的线程 function 相当简单：

void *timeout_worker(void *unused)
{
    struct timespec  when, now;
    struct timeout  *list;

    pthread_mutex_lock(&timeout_lock);
    while (!timeout_quit) {
        clock_gettime(CLOCK_REALTIME, &now);

        /* Let's limit sleeps to, say, one minute in length. */
        when = now;
        when.tv_sec += 60;

        /* Act upon all elapsed timeouts. */
        for (list = timeout_pending; list != NULL; list = list->next) {
            if (timespec_cmp(now, list->when) >= 0) {
                if (!list->elapsed || list->repeat > 0) {
                    const union sigval  value = { .sival_ptr = list };
                    list->elapsed++;
                    pthread_sigqueue(list->thread, TIMEOUT_SIGNAL, value);
                    timespec_add(&(list->when), list->repeat);
                }
            } else
            if (timespec_cmp(when, list->when) < 0) {
                when = list->when;
            }
        }

        pthread_cond_timedwait(&timeout_wait, &timeout_lock, &when);
    }

    /* TODO: Clean up timeouts_pending list. */

    return NULL;    
}

请注意，我没有检查上面的拼写错误，所以可能有一些。 上面的所有代码都在 CC0-1.0 下获得许可：做任何你想做的事，只是不要因为任何错误而责怪我。

Answer 2

不幸的是，您希望将计时器的信号定向到特定线程的行为是不可移植的。

要解决你的 DLL 的幼稚行为——我认为它是错误的幼稚——你有一些可移植的选项。

您可以在exec之前调用已阻止 SIGALRM 的程序。

您的计时器可以指定 SIGEV_THREAD ，然后该线程可以处理超时或通知您的专用线程该工作了。

正如 Glärbo建议的那样，您可以在同步休眠的线程中实现在没有信号的情况下保持自己的时间。