信号量signal，c语言实现

Signals
Description
In this question you’ll be taking a look at how signal handlers behave and are implemented at the kernel level.
The questions you need to answer are:

1. Whathappensifasignalhandlergetsinvokedwhenit’salreadyhandlingasignalforthatsame signal/handler? For example, what happens when a process receives a signal for SIGUSR1 when it’s already handling SIGUSR1?
2. Whathappensifasignalhandlergetsinvokediftheprocessisalreadyhandlingadifferentsig- nal? For example, what happens when a process receives a signal for SIGUSR2 when it’s busy handling SIGUSR1?
   You should write a small program that intentionally creates a situation where these things happen. The program that you write will use the fork system call to create a child process. The child process will register 2 different signal handlers for 2 different signals (SIGUSR1 and SIGUSR2). The parent process will send signals to the child process in a way that forces the above situations to happen.
   The program that you write must use sleep (see man 3 sleep) to make sure that:
   • The child process is able to register the signal handlers before the parent process sends signals,
   •The child process is “busy handling a signal” when the parent process tries to send it more signals.

翻译成中文就是，父进程 fork 出一个子进程。
子进程可以处理信号。
父进程向子进程发射信号。
看看一下两个情况会发生什么：
情况一： 子进程在处理 信号a，此时 发射信号b会怎么样？
情况二：子进程在处理信号a，此时父进程再发射一个信号a会怎么样？

上代码：

#include <stdio.h> //标准输入输出包
#include <unistd.h> //fork包
#include <signal.h> //信号包

void SignHandler1 (int arg) {//用于处理信号1
    int time = 0; //用来标记次数
    while(1)
    {//模仿处理函数1在忙 
        printf("executing signal1...%d times\n", time++);
        sleep(1);
    }
}

void SignHandler2 (int arg) {//同上
    int time = 0;
    while(1)
    {
        printf("executing signal2...%d times\n", time++);
        sleep(1);
    }
}


int main ()
{
    pid_t id;
    id=fork();//fork子进程
    if (id < 0){
        printf("error in fork!");
    }
    else if (id == 0) {// child process
        
        //注册信号--处理函数。信号一交给SignHandler1处理
        signal(SIGUSR1, SignHandler1);
        //信号二交给SignHandler2处理
        signal(SIGUSR2, SignHandler2);

		//阻塞住，等待父进程给子进程传递信号
        while(1)
        {
            printf("sleep 1 second...\n");
            sleep(1);
        }

    }
    else { //father process
    	//睡3秒，保证子进程注册完毕
        sleep(3);
        //开始发第一个信号
        kill(id,SIGUSR1);
        //再睡3秒，以保证子进程有足够的时间处理SIGUSR1
        sleep(3);
        //发送第二个信号
        kill(id,SIGUSR2);
        //同上
        sleep(3);
        //发送第三个信号
        kill(id,SIGUSR2);
        //阻塞住，方便我查看控制台
        while(1)
        {
            sleep(1);
        }
    }
    return 0;
}

结果如下
/子进程开始了，在等待父进程给信号/
sleep 1 second…
sleep 1 second…
sleep 1 second…
sleep 1 second…
/父进程给了信号1，开始执行，0.1.2.3执行了三秒/
executing signal1…0 times
executing signal1…1 times
executing signal1…2 times
executing signal1…3 times
/父进程给了信号2，重新执行，0.1.2.3。。。。执行了三秒/
/然后应该是4的时候，父进程又输入一个信号二，但是没什么卵用/
executing signal2…0 times
executing signal2…1 times
executing signal2…2 times
executing signal2…3 times
/所以重复信号不改变子进程状态/
executing signal2…4 times
executing signal2…5 times
executing signal2…6 times
executing signal2…7 times
executing signal2…8 times
executing signal2…9 times
executing signal2…10 times
executing signal2…11 times
executing signal2…12 times
executing signal2…13 times
executing signal2…14 times

结论：
情况一： 子进程在处理 信号a，此时父进程发射信号b，子进程结束函数1，开始执行函数2来处理信号b。

情况二：子进程在处理信号a，此时父进程再发射一个信号a，子进程无事发生。该干啥干啥。

One more thing

需要Copilot、JetBrains 全家桶全插件全主题，详情可以咨询客服，关注【AIGoland之星】，添加“星标”， 获取每天技术干货，突破自我，成为牛逼架构师。

例如：
回复【ebook】百余本精选电子书
回复【jetbrain】解放开发工具

更多惊喜关注后获得