【Linux】信号

//myproc.cc
#include
#include
using namespace std;
int main()
{
    while(1)
    {
        sleep(1);
    }
    return 0;
}

信号捕捉 signal

#include<iostream>
#include<unistd.h>
#include<signal.h>
using namespace std;
void handler(int signo)
{
    cout<<"捕捉到的信号：" <<signo<<endl;
}
int main()
{
    //只有当SIGINT(ctrl+c)产生的时候才会调用handler函数
    signal(SIGINT,handler);
    while(true)
    {
        cout<<"还未捕捉到SIGINT"<<endl;
        sleep(1);
    }
    return 0;
}

 

我们可以使用2号信号(ctrl+c）、3号信号（ctrl+\)、9号信号（kill -9)来终止进程，其中9号信号是不能被捕捉，永远都是默认处理方式

 自己实现一个kill命令

#include<iostream>
#include<unistd.h>
#include<stdlib.h>
#include<cstring>
#include<sys/types.h>
#include<signal.h>
#include<signal.h>
using namespace std;
void handler(int signo)
{
    cout<<"捕捉到的信号：" <<signo<<endl;
}
static void Usage(const string &proc)
{
    cerr << "Usage:\n\t" << proc << "signo pid" << endl;
}
// mykill 9 1234
int main(int argc, char *argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    if(kill( static_cast<pid_t>(atoi(argv[2])), atoi(argv[1])) == -1)
    {
        cerr << "kill:" << strerror(errno) << endl;
        exit(2);
    }
 
    return 0;
}

raise()

给自己发送一个信号

abort()

终止进程，发送6号信号，可以被捕捉但是还是会终止

 alarm()

将14号信号在seconds秒后发给该进程

进程崩溃的本质是该进程收到了异常信号

#include<iostream>
#include<signal.h>
#include<unistd.h>
using namespace std;
void handler(int sig)
{
    cout << "进程："<< getpid() << "收到一个信号 ：" << sig << endl;
    exit(1);
}
int main()
{
    for(int i = i ;i <= 32; i++)
    {
        signal(i,handler);
    }
    int a = 10;
    a/=0; //除0错误
 
 
    return 0;
}

#include<iostream>
#include<signal.h>
#include<unistd.h>
using namespace std;
void handler(int sig)
{
    cout << "进程："<< getpid() << "收到一个信号 ：" << sig << endl;
    exit(1);
}
int main()
{
    for(int i = i ;i <= 32; i++)
    {
        signal(i,handler);
    }
    int* p = nullptr;
    *p = 23; //空指针错误
    return 0;
}

 man 7 signal

 Action表是接收到信号后执行的动作，Term表示终止，Core表示除了终止外，还会生成一个core文件，这个文件在云服务器上是默认关闭的，需要设置才能打开 

对于一些代码内部原因而产生的错误一般都会有Core文件，这个文件可以帮助我们定位错误，方便调试

内核结构

 阻塞表示拦截信号（区别忽略，忽略是处理中的一种），当信号被处理后，未决中的1变为0

信号集操作函数

上图的中阻塞和未决标志是通过位图来实现的，但是用户层不允许直接使用位操作，所以提供了信号集操作，sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态

#include 
int sigemptyset(sigset_t *set);//初始化set所指向的信号集,使其中所有信号的对应bit清零
int sigfillset(sigset_t *set);//初始化set所指向的信号集,使其中所有信号的对应bit变为1
int sigaddset (sigset_t *set, int signo);//在特定的信号集中，加入特定的信号
int sigdelset(sigset_t *set, int signo);//在特定的信号集中，去掉特定的信号
int sigismember（const sigset_t *set, int signo); //查看一个信号是否在该信号集中

sigprocmask

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集)

#include 
int sigprocmask(int how, const sigset_t *set, sigset_t *oset); 
返回值:若成功则为0,若出错则为-1

how的可选值

sigpending

int sigpending(sigset_t *set)

获取当前进程的pending信号集

#include<iostream>
#include<signal.h>
#include<unistd.h>
#include<sys/types.h>
#include<wait.h>
using namespace std;
void handler(int sig)
{
    cout << "进程："<< getpid() << " 收到一个信号 ：" << sig << endl;
    exit(1);
}
//打印pending信号集
void showPending(sigset_t* pendings)
{
    for(int sig = 1; sig < 32; sig++)
    {
        if(sigismember(pendings,sig))
        {
            cout << "1";
        }
        else{
            cout << "0";
        }
    }
    cout << endl;
}
int main()
{
    cout << "pid: " << getpid() << endl;
    
    sigset_t blockSig, o_blockSig;
    sigemptyset(&blockSig);
    sigemptyset(&o_blockSig);
    //sigfillset()
    for(int sig = 1; sig <= 31;sig++)
    {
        sigaddset(&blockSig,sig);
        signal(sig,handler);
    }
    sigprocmask(SIG_SETMASK, &blockSig, &o_blockSig);
 
    //1.不断的获取当前进程的pending信号集
    sigset_t pendings;
    int cnt = 0;
    while(true)
    {
        //1.1 清空信号集
        sigemptyset(&pendings);
        if(sigpending(&pendings) == 0)
        {
            showPending(&pendings);
        }
        sleep(1);
        cnt++;
        if(cnt == 20)
        {
            cout << "解除对所有信号的block"<<endl;
            sigset_t sigs;
            sigemptyset(&sigs);
            sigaddset(&sigs, 2);
            sigprocmask(SIG_UNBLOCK, &sigs,nullptr);
        }
    }
    
    return 0;
}

进程信号是从内核态转为用户态的时候处理的

sigaction

  

#include<iostream>
#include<unistd.h>
#include<signal.h>
using namespace std;
void handler(int signo)
{
    cout << "进程：" << getpid() <<"获取到一个信号： "<< signo << endl;
    sigset_t pending;
    while(true)
    {
        sigpending(&pending);
        cout<<"pending :";
        for(int i = 1; i <= 31; i++)
        {
            if(sigismember(&pending,i))
            {
                cout << '1';
            }
            else
            {
                cout << '0';
            }
        }
    }
}
int main()
{
    struct sigaction act, oact;
    act.sa_handler =handler;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask,3);
    sigaction(2,&act,&oact);
 
    while(true)
    {
        cout <<" main running" << endl;
        sleep(1);
    }
    return 0;
}

 volatile

#include
#include
#include
using namespace std;
int flag = 0;
void handler(int sig)
{
    flag = 1;
    cout<< "flag: 0->1"<
}
int main()
{
    signal(2,handler);
    while(flag != 1);
    printf("进程退出\n");
    return 0;
}

 优化程度高的编译器会把flag放入寄存器，屏蔽了CPU对内存的可见性，而在handler中对flag的修改会放回到内存中，但是CPU没去内存读取，进程没法退出

#include
#include
#include
using namespace std;
//进制编译器优化，保持对内存的可见性
volatile int flag = 0;
void handler(int sig)
{
    flag = 1;
    cout<< "flag: 0->1"<
}
int main()
{
    signal(2,handler);
    while(flag != 1);
    printf("进程退出\n");
    return 0;
}

SIGCHLD

 子进程退出的时候会给父进程发送SIGCHLD信号

#include<iostream>
#include<unistd.h>
#include<signal.h>
using namespace std;
 
void handler(int signo)
{
    cout<<"进程：" << getpid() << "收到一个信号 :" << signo << endl;
}
int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        sleep(1);
        exit(1);
    }
    else
    {
        //父进程
        signal(SIGCHLD,handler);
        sleep(5);
    }
 
    return 0;
}

 在父进程等待子进程的过程中，每次都是父进程主动询问，而有了这个信号，父进程只需等这个信号过了，然后回收僵尸进程即可

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <signal.h>
#include <cassert>
 
using namespace std;
 
void FreeChld(int signo)
{
    assert(signo == SIGCHLD);
    while (true)
    {
        // waitpid 什么时候调用失败呢？如果你已经没有子进程了
        // -1: 等待任意一个子进程
        pid_t id = waitpid(-1, nullptr, WNOHANG); // bug?？
        if (id > 0)
        {
            cout << "父进程等待成功, chld pid: " << id << endl;
        }
        else if(id == 0)
        {
            //还有子进程，但是现在没有退出
            cout << "还有子进程，但是现在没有退出, 父进程要去忙自己的事情了" << endl;
            break;
        }
        else
        {
            cout << "父进程等待所有子进程结束" << endl;
            break;
        }
    }
}
 
int main()
{
    // signal(SIGCHLD, FreeChld);
    // 子进程退出的时候，默认的信号处理就是忽略吗？
    // 调用signal/sigaction SIG_IGN, 意义在哪里呢？
    // SIG_IGN手动设置，让子进程退出，不要给父进程发送信号了，并且自动释放
    signal(SIGCHLD, SIG_IGN);
    for (int i = 0; i < 10; i++)
    {
        pid_t id = fork();
        if (id == 0)
        {
            //子进程
            int cnt = 10;
 
            // if (i < 7)
            //     cnt = 5;
            // else
            //     cnt = 20;
            while (cnt)
            {
                cout << "我是子进程, pid: " << getpid() << " 当前的cnt: " << cnt-- << endl;
                sleep(1);
            }
            cout << "子进程退出，进入僵尸状态" << endl;
            exit(0);
        }
        // sleep(1);
    }
 
    while (true)
    {
        cout << "我是父进程，我正在运行: " << getpid() << endl;
        sleep(1);
    }
    // //父进程,都是要自己主动等待
    // if(waitpid(id, nullptr, 0) > 0)
    // {
    //     cout << "父进程等待子进程成功" << endl;
    // }
    return 0;
}

用sigaction将SIGCHLD的处理动作置为SIG_IGN,这样fork出来的子进程在终止时会自动清理掉,不 会产生僵尸进程,也不会通知父进程。