0

我正在运行以下实现计时器的程序。当线程从前一个运行线程接收到条件变量信号后唤醒时，它会创建一个计时器并在计时器到期时向下一个线程发送信号。我希望它运行一段时间，但定时器在运行一段时间后停止滴答作响。

//Import 
#define _POSIX_C_SOURCE 199309
#include <sched.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include <signal.h>
#include <errno.h>
#define NUM_THREADS 10

#define CLOCKID CLOCK_REALTIME
#define SIG SIGUSR1
timer_t timerid;

pthread_cond_t   condA[NUM_THREADS+1]  = PTHREAD_COND_INITIALIZER;
pthread_mutex_t  mutex  = PTHREAD_MUTEX_INITIALIZER;

pthread_t tid[NUM_THREADS];
int state = 0;

static void handler(int sig, siginfo_t *si, void *uc)
{
    if(si->si_value.sival_ptr != &timerid){
        printf("Stray signal\n");
    } else {
        //printf("Caught signal %d from timer\n", sig);
    }

        pthread_cond_signal(&condA[state]);
}

void *threadA(void *data_)
{
    int i = 0, s;
    long int loopNum, j;

    int turn = (intptr_t)data_;

    struct timeval tval_result;

    // Timer's part starts

    struct sigevent sev;
    struct itimerspec its;
    long long freq_nanosecs;
    sigset_t mask;
    struct sigaction sa;
    // TImer'spart ends

    while(1)
    {

        /* Wait for state A */
        pthread_mutex_lock(&mutex);

        for (;state != turn;)
        {
            s = pthread_cond_wait(&condA[turn], &mutex);
            if (s != 0)
                perror("pthread_cond_wait");
           // printf("main(): state = %d\n", state);
        }
        pthread_mutex_unlock(&mutex);

        //do stuff
        for(j=0;j<10000;j++)
            {//some dummy time consuming works}

        sa.sa_flags = SA_SIGINFO;
        sa.sa_sigaction = handler;
        sigemptyset(&sa.sa_mask);
        sigaction(SIG, &sa, NULL);

        sev.sigev_notify = SIGEV_SIGNAL;
        sev.sigev_signo = SIG;
        sev.sigev_value.sival_ptr = &timerid;
        timer_create(CLOCKID, &sev, &timerid);
        /* Start the timer */

        its.it_value.tv_sec = 0;
        its.it_value.tv_nsec = 2000;
        its.it_interval.tv_sec = 0;
        its.it_interval.tv_nsec = 0;

        timer_settime(timerid, 0, &its, NULL);
        pthread_mutex_lock(&mutex);
        state = (state +1)%NUM_THREADS;
        //pthread_cond_signal(&condA[state]);
        pthread_mutex_unlock(&mutex);
        // Timer's code ends
    }

}

int main(int argc, char *argv[])
{
    int data = 0;
    int err;

    while(data < NUM_THREADS)
    {
        //create our threads
        err = pthread_create(&tid[data], NULL, threadA, (void *)(intptr_t)data);
        if(err != 0)
            printf("\ncan't create thread :[%s]", strerror(err));
        else
           // printf("\n Thread created successfully\n");

        data++;
    }

    pthread_exit(NULL);
}

虽然没有执行 printf 语句，但为什么一段时间后它会冻结？如果不。的计时器是有限的，我应该使用什么其他策略来解决这个问题？

4

1 回答 1

2

POSIX 说：

在异步调用的信号处理程序中使用 pthread_cond_signal() 函数是不安全的。

很可能你最终会破坏pthread_cond_wait/的状态，pthread_cond_signal任何事情都可能发生。

不要混合线程和信号处理程序，它只会导致疯狂。在信号处理程序中允许您做的事情很少，与线程相关的事情更少，很难确保正确的线程最终处理正确的信号等。

如果你无论如何都在做线程，那么在一个线程中实现一个计时器，它计算它需要休眠多少时间来传递下一个事件（不要只是将它硬编码到你的计时器周期，因为这会使你的计时器漂移），睡那么多并打电话pthread_cond_signal。

此外，赤裸裸的调用是一种糟糕的形式，pthread_cond_signal而且通常是一个错误。您可能会很不走运，并在另一个线程执行之前调用它，pthread_cond_wait并且您的信号将丢失。正常的做法是设置一个变量（受互斥锁保护，这就是pthread_cond_signal需要互斥锁的原因），然后发出设置变量的信号。

如果您认为这工作量太大，那么在这种情况下，条件变量可能不是正确的机制，您应该使用信号量。顺便说一句sem_post，根据 POSIX 从信号处理程序调用是合法的，但我仍然认为将线程与信号混合是一个坏主意。

于 2016-02-22T15:06:04.840 回答