时间戳

首页 > 解决方案 > c 每 n 秒检查一次信号

c - c 每 n 秒检查一次信号

问题描述

我很想编写一个程序，每 5 秒检查一次接收到的所有信号并根据它们改变其输出。我的主要问题是让代码实际上等待 5 秒，因为一旦处理信号，函数 sleep() 就会被中断。我试图做的是将程序分成两个进程，只有孩子处理信号，并通过管道进行通信。问题是，由于管道阻​​塞，在前 5 秒之后，父母只会尝试在那里阅读，基本上使睡眠无用。

从理论上讲，我应该能够仅使用我包含的库（或替代 pthread 库，这是一个分配）来解决此类问题，否则我看到我可以使用其他库来使管道不阻塞，但此刻我'我对如何解决这个问题缺乏想法（我也尝试过使用线程失败的尝试）。

我附上代码以供参考，在此先感谢。

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int p[2];//pipe

void sigHandler (int sig) {
    char c;
    switch (sig) {
        case SIGUSR1:
            c = '1';
        break;
        case SIGUSR2:
            c = '2';
        break;
        case SIGALRM:
            c = '0';
        break;
        case SIGSTOP:
            exit (0);
        break;
    }
    write(p[1], &c, sizeof(char));
}


int main(int argc, char **argv) {
    int signals[3], sig, i;
    for (i=0; i< 3; i++) {
        signals[i] =0;
    }
    pid_t pid;
    char csig;
    pipe(p);

    /*fork code*/
    pid = fork();

    /*parent*/
    if (pid) { 
        close(p[1]);
        int proceed = 1;

        /*cycle keeps on indefinitely*/
        while (proceed) {
            sleep(15); //increased the time so I have time to send signals
            while (read(p[0], &csig, sizeof(char)) > 0) {
                sig=atoi(&csig);
                signals[sig]++;

                /*if alternating sigals, error*/
                if (signals[1] && signals[2]) {
                    printf("Error: alternating SIGUSR1 and SIGUSR2\n%d\t%d\n", signals[1], signals[2]);

                }
                /*if 2 consecutive signals, success*/
                if (signals[sig] == 2) {
                    printf("Success: two consecutive SIGUSR1 or SIGUSR2\n");
                }
                /*if three consecutive signals, exit*/
                if (signals[sig] == 3) {
                    kill(pid, SIGSTOP);
                    proceed = 0;
                    break;
                }
                /*make 0 any non repeating signal != sig*/
                for(i = 0; i< 3; i++) {
                    if (i != sig) {
                        signals[i] = 0;
                    }
                }
            }
        }
    /*child*/
    } else {
        close(p[0]);
        signal(SIGUSR1, sigHandler);
        signal(SIGUSR2, sigHandler);
        signal(SIGALRM, sigHandler);
        signal(SIGSTOP, sigHandler);
        while (1) {
            sleep(5); //no need to do anything else
        }
        exit(1);

    }
    return 0;
}

标签： csignalssleep

解决方案

clock_nanosleep让你睡到一个绝对的时间。您可以重复调用此函数，直到达到所需的时间。

struct timespec time_now;
clock_gettime(CLOCK_REALTIME, &time_now);
time_now.tv_sec += 5;
time_now.tv_nsec = 0;
while(clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &time_now, NULL) == EINTR);

这将使您的线程反复休眠，直到它完成 5 秒的休眠。在您的信号处理程序中，您不断将接收到的信号添加到一个数组中，并在睡眠结束后处理它。

推荐阅读