我打算编写一个程序,该程序每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;
}
答案 0 :(得分:1)
答案 1 :(得分:1)
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秒钟的睡眠为止。 在信号处理程序中,您一直将接收到的信号添加到数组中,并在休眠结束后对其进行处理。
答案 2 :(得分:0)
为什么这么复杂?信号是每个进程的(使用POSIX线程时,可选地是同一进程中的每个线程),因此仅使用多个进程来处理信号是没有意义的。
考虑以下程序:
#define _POSIX_C_SOURCE 200809L
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <time.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
static const char *signal_name(const int signum)
{
switch (signum) {
case SIGUSR1: return "SIGUSR1";
case SIGUSR2: return "SIGUSR2";
case SIGALRM: return "SIGALRM";
case SIGSTOP: return "SIGSTOP";
case SIGINT: return "SIGINT";
default: return "unnamed";
}
}
int main(void)
{
siginfo_t info;
sigset_t mask;
int signum;
sigemptyset(&mask);
sigaddset(&mask, SIGUSR1);
sigaddset(&mask, SIGUSR2);
sigaddset(&mask, SIGALRM);
sigaddset(&mask, SIGSTOP);
sigaddset(&mask, SIGINT);
/* Block the signals in mask. */
if (sigprocmask(SIG_BLOCK, &mask, NULL) == -1) {
fprintf(stderr, "Cannot block signals: %s.\n", strerror(errno));
exit(EXIT_FAILURE);
}
printf("Process %d is ready for USR1 and USR2 signals.\n", (int)getpid());
fflush(stdout);
/* Ensure we receive a SIGALRM signal in five seconds or so. */
alarm(5);
while (1) {
/* Receive one of the signals in mask. */
signum = sigwaitinfo(&mask, &info);
if (signum == -1) {
const int err = errno;
/* EINTR should not happen, but if it did, it would be okay. */
if (err == EINTR)
continue;
fprintf(stderr, "sigwaitinfo() failed: %s (%d).\n", strerror(err), err);
exit(EXIT_FAILURE);
}
/* Describe the received signal. */
if (info.si_pid)
printf("Received %s (signal %d) from process %d.\n", signal_name(signum), signum, (int)info.si_pid);
else
printf("Received %s (signal %d).\n", signal_name(signum), signum);
fflush(stdout);
/* It is time to exit, if we receive INT or STOP, */
if (signum == SIGINT || signum == SIGSTOP)
break;
/* or an ALRM timeout; don't be fooled by kill()/sigqueue() SIGALRM. */
if (signum == SIGALRM && !info.si_pid)
break;
}
printf("Done.\n");
return EXIT_SUCCESS;
}
mask
包含被阻止且仅通过sigwaitinfo()
接收的信号集。 alarm(5)
确保在5秒钟左右的时间内传递SIGALRM信号。如果设置了info.si_pid
,则信号是通过kill()
(或类似的特定于OS的系统调用)发送的。
此程序仅描述它收到的每个信号,直到触发警报超时,或者它收到SIGSTOP或SIGINT信号。 (当您在终端中运行程序,并按 Ctrl + C 时,终端会向(前景)进程发送SIGINT信号。)
您不能通过发送SIGALRM信号来欺骗程序,因为内核将.si_pid
结构的siginfo_t
字段设置为发送过程。对于所有“原装”警报,该值为零。
请记住,标准Unix / POSIX信号没有排队,并且可能有延迟(例如睡眠和计时器,可能比预期的要晚发送)。