【Linux】信号

最新推荐文章于 2024-09-06 10:38:06 发布
最新推荐文章于 2024-09-06 10:38:06 发布
阅读量427 收藏
点赞数
文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/holle_world_ldx/article/details/127861572
版权 
//myproc.cc
#include<iostream>
#include<unistd.h>
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 <signal.h>
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 <signal.h>
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<iostream>
#include<unistd.h>
#include<signal.h>
using namespace std;
int flag = 0;
void handler(int sig)
{
    flag = 1;
    cout<< "flag: 0->1"<<endl;
}
int main()
{
    signal(2,handler);
    while(flag != 1);
    printf("进程退出\n");
    return 0;
}

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

#include<iostream>
#include<unistd.h>
#include<signal.h>
using namespace std;
//进制编译器优化，保持对内存的可见性
volatile int flag = 0;
void handler(int sig)
{
    flag = 1;
    cout<< "flag: 0->1"<<endl;
}
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出来的子进程在终止时会自动清理掉,不 会产生僵尸进程,也不会通知父进程。

Patrick star`
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux 信号
sqjddb的博客
03-17 1446
>>认识信号 >>产生信号 >>处理信号 >>信号在内核中的表示 >>信号集处理函数 >>信号捕捉
linux信号
03-28
这篇博客文章“Linux信号”可能详细介绍了信号的概念、使用以及在实际操作中的应用。由于没有直接提供博客内容，这里将根据常规的Linux信号知识进行详细阐述。 **信号的基本概念** 信号是Linux和其他类Unix系统中的...
SIGCHLD信号
Cecilia3333的博客
04-09 860
在进程的学习中，我们用wait和waitpid函数清理僵尸进程，父进程可以阻塞式等待子进程结束，也可以非阻塞地查询是否有子进程结束等待清理（即轮询方式）。采用第一种方式，父进程阻塞式等待，就不能处理自己的工作了；采用第二种方式，父进程在处理自己工作的同时还要记得时不时地轮询一下，程序实现复杂。其实，子进程在终止时会给父进程SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自定义SIGCHL...
一个特殊的信号---- SIGCHILD
chenkaixin_1024的博客
08-31 6604
这里重点提一下SIGCHLD信号（17号信号），对于父进程而言，一般要对它的子进程进行等待，以防止子进程变为僵尸进程，而导致内存泄漏问题，但是对于父进程的等待方式存在两种：阻塞式等待和非阻塞式等待，可以通过wait和waitpid这两个系统调用来实现，对于父进程而言，阻塞式等待让父进程停下自己手头上的事情，专心的等待子进程退出，这严重影响了父进程的工作；而对于非阻塞式等待，父进程每隔一段时间都要轮
进程信号——捕捉信号和可重入函数及SIGCHLD
DuckyLoser的博客
04-20 336
捕捉信号一、内核实现信号的捕捉    操作系统会在适当的时候给进程发送信号，但是什么时候是最适当的呢？在上图中，在内核态到用户态的时候会对信号进行处理，同时进行检测，如果这时候发现异常，操作系统就会发送信号。sighandler和main函数是使用不同的堆栈空间，它们之间不存在调用和被调用的关系，是两个独立的控制流程。二、sigactionint sigaction(int signo,const...
一个重要且实用的signal---SIGCHLD
lyztyycode的博客
10-02 1733
SIGCHLD 先来看看信号的基本概念： 信号kill-l查看linux信号及其宏定义编号，其中1~31非实时编号（发送的信号可能丢失，不支持信号排队），31~64实时信号，发送的信号都会被接收（支持信号排队） 信号的定义在/usr/include/bits/signum.h 1.信号是软件中断 2.信号是异步信号 3.信号的来源： (1)、硬件来源：主要是硬件的驱动产生，如键盘
signal(SIGCHLD, SIG_IGN)
sweetfather的博客
03-06 3371
SIGCHLD信号子进程结束时, 父进程会收到这个信号。 如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情 况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程 来接管)。SIG_ING忽略的意思使用signal(SI...
Linux信号
潜心钻研技术
03-19 2580
信号是一种条件反射，不管事件有没有发生，但是你对带这件事情的处理方式是固定的。这件事情的发生对你来说就是一种信号。操作系统也存在信号，实际上os中的信号：是操作系统向进程传达指令的一种操作。操作系统向进程发出信号，进程接受到信号执行相应的动作。输入指令kill -lkill -signum 进程pidsignum 为信号编号这里每个信号都有一个字字母标识该信号信号从操作系统发出到信号被执行一共要经理三个过程：下面就让我们从这三个方面来对信号深入了解。
Linux信号列表.pdf
09-27
Linux信号列表 Linux操作系统中，信号（Signal）是一种异步事件，用于通知进程发生了某些事件，例如键盘中断、进程终止、内存访问错误等。Linux支持的信号列表包括传统UNIX支持的不可靠信号（1-31）和后来扩充的...
tebata:用于golang的简单Linux信号处理程序
05-14
Go的简单Linux信号处理程序 安装 go get -u github.com/syossan27/tebata 用法 package main import ( "fmt" "strconv" "syscall" "github.com/syossan27/tebata" ) func main () { t := tebata . New ( ...
Linux信号1
08-08
【Linux信号】是操作系统提供的一种进程间通信机制，主要用于通知进程发生了特定事件。信号是软件中断，不携带数据，仅用于触发进程响应。在Linux环境下，我们可以通过`kill`和`killall`命令来发送不同类型的信号。 ...
signal()函数的使用及小结
reason的博客
02-03 2485
Signal ()函数用法和总结https://www.cnblogs.com/wuyepeng/p/9790396.html Linux C++应用程序退出时的事件响应https://blog.csdn.net/fk2016/article/details/83381246 void（* signal（int sig，void（* func）（int）））（int）; 使用示例： #include <stdio.h> #include <stdlib.h> #i..
signal(SIGCLD,SIG_IGN)
cpxsxn的博客
08-19 1005
遇到信号量的问题？ signal(SIGCLD,SIG_IGN) SIGCHLD的语义为:子进程状态改变后产生此信号，父进程需要调用一个wait函数以确定发生了什么。 对于SIGCLD的早期处理方式如下:如果进程特地设置该信号的配置为SIG_IGN,则调用进程的子进程将不产生僵死进程。 如果将SIGCLD的配置设置为捕捉，则内核立即检查是否有子进程准备好被等待，如果是这样，则调用SIGCLD处理程序。 APUE上SIGCLD语义写的有点不清楚，到底我们的系统是如何来处理SIGCLD信号呢？ 1.SIG_DF
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 513
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【算法】C++贪心算法解题（单调递增数字、坏了的计算器、合并区间）
卜及中的博客
09-03 595
【算法】贪心算法解析：基本概念、策略证明与代码例题演示。
LeetCode LCR088.使用最小花费爬楼梯
m0_63816268的博客
09-03 1041
动态规划
树状数组记录
最新发布
volcan的博客
09-06 443
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
P7492 [传智杯 #3 决赛] 序列
summ1ts的博客
09-03 402
的数组，表示区间内所有数的二进制表示下某一位是否为1，但这太难写，最后无奈去看官方题解，发现只要维护区间所有数的按位与和And，如果(And&k)==k的话那就不用修改了。那样的话这个题就很简单了，维护最大子段和可以见。一道类似势能线段树的题，区间按位或上k，不满足区间可合并的性质，只能暴力的单点修改。，如果我们能找到一个方法，能够判定区间里的数，或上k后是否有改变，就可以避免。至于时间复杂度用类似势能分析的方法分析一波就行了，时间复杂度。我一开始想的是线段树里维护一个。但是考虑按位或的性质，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值