【Linux】了解信号产生的五种方式

已于 2024-05-13 11:22:16 修改
阅读量1.1k 收藏 21
点赞数 18
文章标签： 信号产生 Linux 操作系统
于 2024-05-07 19:28:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljh1257/article/details/138473327
版权

文章目录

正文前的知识准备

kill 命令查看信号

在命令行终端输入命令kill -l快速查看信号列表
在这里插入图片描述

信号列表中的每一项都由【数字】和【名字】两部分构成，但是信号本质上就只是一个【数字】而已，【名字】只是一个宏，如何证明，看源码定义：
在这里插入图片描述

信号列表中一共有62个信号，没有0、32、33号信号，信号可以分成实时信号（34 ~ 64）和非实时信号（1 ~ 31），后面谈到的所有内容只涉及非实时信号。

man手册查看信号

kill -l只是简单罗列一下OS中有哪些信号而已，这种方式不足以了解到更多的知识，还有另外一种查看信号的方式——man 手册。

man 7 signal 命令可用于查看 Linux 中有关信号的手册页。这个命令会显示与信号相关的信息，其中包含了关于信号的详细信息，如信号的编号、名称、含义、默认处理方式等，可以更好地理解信号的概念和用法。（文章后面的很多地方都会用到表里的内容）
在这里插入图片描述

信号的处理方法

信号的完整生命周期通常分为3个阶段：信号的产生、信号的保存、信号的处理。
本来信号的处理不是放在文章的内容，但是为了更好的理解信号产生的现象，这里提前了解一下。在这里插入图片描述

信号的处理方法有三种：

  1. 默认：man手册中提到，OS为每个信号都设置了一个默认行为，当一个进程收到信号时会执行对应的行为。
  2. 自定义捕捉：当进程收到一个信号，不执行默认行为转而执行程序员指定的行为，这个过程称之为 “自定义捕捉”。
  3. 忽略：进程收到信号之后什么都不做，即忽略该信号。

这里介绍一个能够更改进程信号处理方法的系统调用signal。

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

说明：

  • 使用该方法要包含头文件signal.h。
  • sighandler_t是一个函数指针，指向的函数参数个数为1，参数类型为int，返回值类型为sighandler_t。
  • signum是指某个信号，表示对该信号设置自定义处理方法。
  • handler是程序员对信号signum的自定义处理方法。
  • 该方法的作用是将进程收到信号signum的处理动作由默认改为程序员自定义的handler方法，即当进程收到信号signum时，不再执行默认的处理动作，转而执行程序员自定义的handler方法来处理处理信号signum。

注意：signal被调用时，handler方法不会被立即执行，而是进程收到信号之后才会被执行，如果没有收到对应的信号，handler方法永远也不会执行。

认识信号产生的5种方式

1. 工具

第一种信号产生的手段就是Linux操作系统内置的 kill 工具，通过该工具能够做到向任意进程发送任意信号。

LJH@hecs-66624:~$ ll /usr/bin/kill
-rwxr-xr-x 1 root root 30952 Sep  9  2021 /usr/bin/kill*

通常，kill命令的使用形式是

kill -<信号编号> <进程ID>

例如，输入命令 kill -9 1234，kill 工具会向 ID 为 1234 的进程发送 SIGKILL 信号，SIGKILL 信号的默认行为强制终止进程。

再介绍一下2号信号 SIGINT，它的默认处理动作的 Term（terminate，终止），即终止一个正在运行的进程。

这里就通过一个实现来验证一下kill命令能否对一个进程发送信号，同时还演示一下该如何使用系统调用signal来设置进程的信号处理方法。

实验内容如下：

  1. 写一个程序死循环向显示器输出 "I am working, my pid is " + 进程 ID。
  2. 在 1 的基础上，通过kill工具发送 2 号信号 SIGINT 来终止该进程，验证进程处理信号 SIGINT 的默认动作。
  3. 在 1 的基础上，先调用signal将进程对信号 SIGINT 的处理动作设置为向显示器输出 "get a signal: " + 收到的信号的数字、然后退出，再进程执行过程中向该进程发送信号 SIGINT，如果输出 “get a signal: 2” 并退出，则说明猜测正确。
  4. 在 1 的基础上，调用signal将进程对信号SIGINT的处理动作设置为忽略，然后在进程运行过程中向该信号发送信号SIGINT，如果信号发送无效，则说明猜测正确。

实验第2步：
代码：

// cpp
#include <iostream>
// system call
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

using namespace std;

int main()
{
    while (true)
    {
        cout << "I am working, my pid is " << getpid() << endl;
        sleep(2);
    }

    return 0;
}

运行过程：
在这里插入图片描述

结论：验证成功，进程处理信号SIGINT的默认动作确实是终止。

实验第3步
代码：

#include <iostream>
#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

using namespace std;

void handler(int signum)
{
    cout << "get a signal: " << signum << endl;
    exit(0);
}

int main()
{
    signal(SIGINT, handler);
    while (true)
    {
        cout << "I am working, my pid is " << getpid() << endl;
        sleep(2);
    }

    return 0;
}

运行结果：
在这里插入图片描述

结论：验证成功，实现了对信号SIGINT的自定义捕捉。

实验第4步
SIG_IGN的定义：

#define	SIG_IGN	 ((__sighandler_t)  1)	/* Ignore signal.  */

代码：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

using namespace std;

int main()
{
    signal(SIGINT, SIG_IGN);
    while (true)
    {
        cout << "I am working, my pid is " << getpid() << endl;
        sleep(2);
    }

    return 0;
}

运行结果
在这里插入图片描述

结论：验证成功，实现了对信号SIGINT的忽略操作。

2. 键盘

Ctrl+C这个组合键是我们在Linux最常用的组合键之一，它能终止正在执行过程中的进程，就像下面这样：
在这里插入图片描述

对于Ctrl+C这个组合键，我们虽然会用，但是却不怎么了解它的原理，既然这里提到了它，就说明它的原理和信号有关，理由是我们输入Ctrl+C组合键被操作系统解析成SIGINT信号，然后发送给了正在运行的进程，SIGINT信号的默认动作是终止进程，所以死循环被终止了。

详细的原理可以看一下个人写的另外一篇文章《解析Linux键盘组合键产生信号的完整过程：从硬件中断到信号发送》

凭什么这么说？接下来就要用一个实验来验证这个结论是否正确。

实验内容如下：
写一个程序，内容是死循环向显示器输出 "I am working, my pid is " + 进程ID，同时调用signal设置对信号SIGINT的捕捉方法为向显示器输出 "get a signal: " + 信号数字，但是不退出，进程执行过程中，不断按下ctrl + c，观察实验现象，如果信号数字是2，就说明收到了信号SIGINT，结论正确。

代码：

#include <iostream>
#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

using namespace std;

void handler(int signum)
{
    cout << "get a signal: " << signum << endl;
    // exit(0);
}

int main()
{
    signal(SIGINT, handler);
    while (true)
    {
        cout << "I am working, my pid is " << getpid() << endl;
        sleep(2);
    }

    return 0;
}

运行结果：
这里能够看到在进程给执行过程中，连续按下Ctrl+C，自定义的handler方法不断被执行，然后向屏幕输出收到了2号信号，说明了上面的结论是正确的。
在这里插入图片描述

于此同时，再分别看一下源码中对信号SIGINT的定义中的注释和man手册对SIGINT的描述

#define	SIGINT		2	/* Interactive attention signal.  */

Signal      Standard   Action   Comment
────────────────────────────────────────────────────────────────────────
SIGINT       P1990      Term    Interrupt from keyboard

“Interactive Interrupt Signal”，交互式中断信号，强调了它是通过用户的交互操作触发的，用于引起程序的注意并中断执行，而man手册中 “Interrupt from keyboard” 的注释表明，这个“交互操作”指的就是 Ctrl+C 这个组合键，Action 项为 Term 表示默认行为是终止进程。

3. 系统调用

在第2点时提到，shell程序通过系统调用来向目标进程发送信号，而系统调用就是产生信号的第3种方式，所以接下来说一下，都有哪些系统调用可以发送信号（说是系统调用，但其实这里只会讲到一个系统调用，其余两个都是C的库函数，不过它们两个的底层都是封装了系统调用，而且3者都是通过代码的形式来实现信号发送，所以这里就一起介绍）。

kill 向任意进程发送任意信号

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

kill 系统调用的功能是向指定的进程发送指定的信号，参数pid是目标进程ID，参数sig是待发送信号，信号发送成功，返回值为0，信号发送失败，返回值为-1，同时错误码(errno)被设置。

理论部分完了，接下来是实验验证，到底 kill 系统调用能不能向一个进程发送信号。

实验内容：
使用 kill 系统调用简单实现一个属于自己的 kill 命令，即 mykill，输入 ./mykill -<信号编号> <进程ID> 能够做到和 kill 命令一样的功能，然后启动一个死循环输出 "I am working, my pid is " + 进程ID 的程序，在另一个窗口向该该进程发送信号SIGKILL，如果死循环进程 Killed，说明 kill 系统调用确实能够向一个进程发送信号。

代码：

---------------./testsig-----------------------
#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

using namespace std;

int main()
{
    while (true)
    {
        cout << "I am working, my pid is " << getpid() << endl;
        sleep(1);
    }

    return 0;
}

---------------./mykill------------------------
#include <iostream>
#include <string>
#include <cstring>
#include <cerrno>
#include <signal.h>
#include <sys/types.h>

using namespace std;

// ./mykill -9 pid
int main(int argc, char* argv[])
{
    if (argc != 3)
    {
        cout << "Usage: " << argv[0] << " -signumber pid" << endl;
        return 1;
    }
    
    int signumber = stoi(argv[1]+1);
    int pid = stoi(argv[2]);

    int n = kill(pid, signumber);

    if (n < 0)
    {
        cout << "kill error, error message: " << strerror(errno) << endl;
        return 2;
    }

    return 0;
}

运行结果：
在这里插入图片描述

raise 给调用方发送任意信号

#include <signal.h>
int raise(int sig);

raise 方法还有下面的 abort 方法严格上来说不算是系统调用，但都属于调用函数发送信号的范畴，并且比较常见，这里也一起研究一下。raise 方法的作用是给调用 raise 的进程发送一个指定的信号 sig，发送成功返回0，发送失败返回一个非0整数。

使用演示：
写一个程序，每秒向显示器输出 "I am working, my pid is " + 进程ID，3秒后向自己发送信号SIGKILL。

代码：

#include <iostream>
#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

using namespace std;

int main()
{
    int cnt = 0;
    while (true)
    {
        if (cnt == 3) 
        {
            cout << "raise: send SIGKILL to caller" << endl;
            raise(SIGKILL);
        }
        cout << "I am working, my pid is " << getpid() << endl;
        cnt++;
        sleep(1);
    }

    return 0;
}

运行结果：
在这里插入图片描述

abort 给调用方发送SIGABRT信号

#include <stdlib.h>
void abort(void);

说明：
abort 方法会向调用该方法的进程发送 SIGABRT 信号，SIGABRT 的全称是 “Signal Abort”，“abort” 的中文意思是 “中止” 或 “放弃”，在计算机术语中指的是异常终止程序的行为，所以，进程处理信号 SIGABRT 的默认动作就是终止进程。

代码验证及使用演示：

#include <iostream>
#include <cstdlib>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

using namespace std;

void handler(int signo)
{
    std::cout << "get a signo: " << signo << std::endl;
    exit(0);
}

int main()
{
    signal(SIGABRT, handler);
    int cnt = 0;
    while (true)
    {
        if (cnt == 3) 
        {
            cout << "abort: send SIGABRT to caller" << endl;
            abort();
        }
        cout << "I am working, my pid is " << getpid() << endl;
        cnt++;
        sleep(1);
    }

    return 0;
}

运行结果：
在这里插入图片描述

4. 软件条件

产生信号的第4种方式就是【软件条件】，相比起前三种，这个看起来就很抽象，个人是这样理解的：在 “软件条件产生信号” 中，“软件” 指的是各种进程或者程序。当某个进程满足了某种条件，比如一个错误的操作、一个特定的事件发生或者一个状态的改变，它可能会向其他进程、操作系统或者它自己发送一个信号，以通知它们发生了某个事件或者需要采取某种行动。

下面来讲一个经典的软件条件的例子，13号 管道信号 SIGPIPE：

管道是进程间通信的手段之一，管道本身是OS提供的基于文件系统实现的一段内核级文件缓冲区，进程A先将数据写入缓冲区中，进程B来读取这样就实现了两个进程间的通信。

而一个管道只能支持单向通信，换言之，通信的进程双方得协商谁是管道的写端，谁是管道的读端，讲这个有意义吗，有意义，因为管道通信中规定了这样一种情况，当管道的读端进程关闭了管道的读端之后，OS会强制终止写端进程，因为管道数据已经没人读取了，再写也已经没有意义。

在这里插入图片描述

上面是结论，中间的原理是这样的，管道本身是OS提供用于进程间通信的资源，OS内部有通信需求的进程肯定不止这两个，所以，OS内肯定会创建很多的管道资源来 为进程提供通信服务，而OS作为计算机软硬件资源的管理者，它内部肯定会有一个描述管道信息的结构体以及组织管理所有管道的数据结构，因此，当某个管道的读端进程将管道的读端关闭了，OS肯定就会知道并将描述管道信息的结构体对象内的信息做修改，当该管道的写端进程尝试写入数据时，OS会检查管道的状态，如果发现该进程满足 “ 向不满足写入条件的管道进行写入 ” 的条件时，OS就会向该进程发送 SIGPIPE 信号，通知它写入操作失败，该进程需要处理这个信号。

首先来看一下man手册对于 SIGPIPE 信号的描述

Signal      Standard   Action   Comment
────────────────────────────────────────────────────────────────────────
SIGPIPE      P1990      Term    Broken pipe: write to pipe with no 
								readers; see pipe(7)

其次惯例操作实验验证，内容如下：

  • pipe_server进程作为管道的读端，从管道中读取数据并输出，读端进程会在运行3秒后退出
  • pipe_client进程作为管道的写端，不停向管道写入数据，同时写端进程对SIGPIPE信号做自定义捕捉，看是否真的收到了SIGPIPE信号。

代码如下：

---------------Command.hpp------------------------
#ifndef __COMMAND_HPP__
#define __COMMAND_HPP__

#include <iostream>
#include <string>
#include <cerrno>
#include <cstdlib>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>

using std::cerr;
using std::cin;
using std::cout;
using std::endl;
#define Mode 0666

class Fifo
{
public:
    Fifo(const char *path) : _path(path)
    {
        umask(0);
        int n = mkfifo(_path.c_str(), Mode);
        if (n == 0)
        {
            cout << "mkfifo success" << endl;
        }
        else
        {
            cerr << "mkfifo failed, errno: " << errno << ", errmsg: " << strerror(errno) << endl;
            exit(1);
        }
    }
    ~Fifo()
    {
        int n = unlink(_path.c_str());
        if (n == 0)
        {
            cout << "remove fifo success" << endl;
        }
        else
        {
            cerr << "remove fifo failed, errno: " << errno << ", errmsg: " << strerror(errno) << endl;
            exit(1);
        }
    }

protected:
    std::string _path;
};

#endif
---------------PipeServer.cc------------------------
#include "Command.hpp"

const char *path = "fifo";

int main()
{
    // 创建管道
    Fifo fifo(path);

    // 获取管道读端
    int rfd = open("fifo", O_RDONLY);
    if (rfd >= 0)
    {
        cout << "open fifo success" << endl;
    }
    else
    {
        cerr << "open fifo failed, errno: " << errno << ", errmsg: " << strerror(errno) << endl;
        exit(1);
    }

    // 读数据
    char buffer[1024]{0};
    int cnt = 4;
    while (cnt--)
    {
        ssize_t n = read(rfd, buffer, sizeof(buffer) - 1);
        if (n > 0)
        {
            buffer[n] = 0;
            cout << "get msg from client: " << buffer << endl;
        }
        else if (n == 0)
        {
            cout << "client quit, me too!" << endl;
            break;
        }
        else
        {
            cerr << "read from fifo failed, errno: " << errno << ", errmsg: " << strerror(errno) << endl;
            break;
        }
    }

    close(rfd);
    return 0;
}
---------------PipeClient.cc------------------------
#include "Command.hpp"

void handler(int signum)
{
    cout << "get a signum: " << signum << endl;
    cout << "Pipe is broken, now I quit" << endl;
    exit(1);
}

int main()
{
    signal(SIGPIPE, handler);
    // 获取管道写端
    int wfd = open("fifo", O_WRONLY);
    if (wfd >= 0)
    {
        cout << "open fifo success" << endl;
    }
    else
    {
        cerr << "open fifo failed, errno: " << errno << ", errmsg: " << strerror(errno) << endl;
        exit(1);
    }

    // 发消息
    const char *inbuffer = "I am process A and I am client";
    while (true)
    {
        ssize_t n = write(wfd, inbuffer, strlen(inbuffer));
        if (n < 0)
        {
            cerr << "write to fifo failed, errno: " << errno << ", errmsg: " << strerror(errno) << endl;
            break;
        }
        sleep(1);
    }

    close(wfd);

    return 0;
}

运行结果：
在这里插入图片描述
在这里插入图片描述

5. 异常

了解过进程的都知道，一个进程退出只会有以下3种场景：

  1. 代码运行完毕，结果正确。
  2. 代码运行完毕，结果不正确。
  3. 代码运行过程中，进程异常终止。

而异常终止的本质原因是因为进程收到了信号，所以，第5种产生信号的方式就是异常。

举两个常见的代码异常，进程收到信号的例子：

  1. 代码除零 8) SIGFPE

下面是一段演示代码，里面写了除零操作。

#include <iostream>
using namespace std;

int main()
{
    int a = 10;
    a /= 0;
    return 0;
}

运行结果：
在这里插入图片描述

运行之后看到，程序输出 “Floating point exception (core dumped)” 后就结束了，为了确认其是否收到了信号，这里使用signal设置自定义捕捉 SIGFPE 信号，代码修改如下：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>

using namespace std;

void handler(int signum)
{
    cout << "get a signum: " << signum << endl;
    sleep(1);
}

int main()
{
    signal(SIGFPE, handler);

    int a = 10;
    a /= 0;

    return 0;
}

输出结果：
在这里插入图片描述

捕捉了之后，确实验证了进程收到了 SIGFPE 信号，但同时也看到了一个很奇怪的现象，明明代码里从头到尾都没有写循环，为什么handler方法会被一直执行？

理由：信号的处理方法从Core退出被改成的向显示器输出一句话，这就导致了原本该退出的进程没有退出，进程没有退出，除零异常就一直存在，进程在被CPU调度时就会一直触发异常，OS会不断地向进程发送 SIGFPE 信号，进程收到信号并处理就会一直向屏幕输出，导致了一种死循环的局面。

  1. 野指针 11) SIGEGV

下面是一份演示代码，里面写了野指针访问操作。

#include <iostream>
using namespace std;

int main()
{
    int *p = nullptr;
    *p = 100;

    return 0;
}

运行结果：
在这里插入图片描述

运行之后看到，程序输出 “Segmentation fault (core dumped)” 后直接退出，为了验证进程是否真的收到了信号，设置自定义捕捉 SIGSEGV 信号，观察是否收到信号，代码修改如下：

#include <iostream>
#include <sys/types.h>
#include <unistd.h>
#include <signal.h>
using namespace std;

void handler(int signum)
{
    cout << "get a signum: " << signum << endl;
    sleep(1);
}

int main()
{
    signal(SIGSEGV, handler);

    int *p = nullptr;
    *p = 100;

    return 0;
}

运行结果：
在这里插入图片描述

ljh1257
关注
Linux系统编程30：进程信号之产生信号的四种方式（Core Dump,kill,raise）
快乐江湖的博客
04-29 696
文章目录（1）通过按键产生信号-Core Dump（2）调用系统函数向进程发送信号A：killB：raiseC：abort（3）由软件条件产生信号（4）硬件异常产生信号总结： 为了方便后面的讲解，我们先要了解一下如何捕捉信号，使用signal函数可以捕捉到发送给这个进程的信号，该函数第一个形参设定要捕捉的信号，第二个形参实则是一个函数指针，指向了一个函数，表明当捕捉到要捕捉的信号时，所要进行的操作 #include <stdio.h> #include <unistd.h> #inc
【Linux操作系统】--进程信号--信号产生前的产生方式
qq_53413129的博客
05-12 489
信号入门 生活角度的信号 生活中有很多信号的场景，比如红绿灯，闹钟，信号枪，鸡叫声等等...，这些信号都是给人看的，如果这些信号脱离了人类，红绿灯给牛看，信号枪给鸟打，鸡给鸡叫，这些都是没有意义的。当这些场景触发的时候，我们人类立马就知道要做什么。那么是不是这些场景真正放在我们面前，我们才知道做什么呢？其实和场景触发没有直接关联。对于信号的处理动作，我们早就知道了，甚至远远早于信号产生。那么我们是怎么做到没有信号就知道该怎么做呢？我们对特定事件的反应，是被教育的结果，本质是我们记住了。 结论1：所以信
linux中的信号
qq_28576837的博客
06-22 217
linux中的信号
【Linux】信号的产生方式
qq_42270373的博客
01-12 961
一.通过键盘终端产生信号 我们知道2号信号SIGINT的默认处理动作是终止该进程，3号信号SINQUIT的默认处理动作是终止进程并且Core Dump。首先先介绍一下什么是Core Dump。 Core Dump Core Dump叫做核心转储，所谓核心转储是指当进程因为异常而终止时，把进程中的内存数据保存一份到硬盘上的过程。进程异常终止通常是因为有bug，比如野指针，除0等导致段错误...
【Linux】产生信号的方式
chuxinchangcun的博客
03-19 585
C/C++程序会崩溃,是因为程序当中出现的各种错误最终一定会在硬件层面上有所表现,进而会被操作系统识别到,然后操作系统就会发送相应的信号将当前的进程终止。
Linux 信号的介绍
weixin_65665343的博客
01-15 346
Linux信号的介绍 以及一些基本函数接口的调用
Linux信号
Peerless__的博客
10-05 1556
信号是由用户、系统或进程发送给目标进程的信息，以通知目标进程某个状态的改变或系统异常，Linux中有很多种不同的信号。可以在终端输入kill -l 来查看Linux支持的信号，如下图： Linux信号可由如下条件产生： 1、对于前台进程，用户可以通过输入特殊的终端字符来发送，比如输入Ctrl+C通常会给正在运行的进程发送一个中断信号。 2、系统异常。比如浮点异常和非法内存段访问。 3、系统状态变化。比如alarm定时器到期时将引起SIGALRM信号。 4、在终端运行kill命令或在程
Linux进程信号产生以及捕捉
pythoncjave的博客
02-15 1071
生活中，有哪些信号相关的场景呢，比如：红绿灯，闹钟，转向灯等等。1.这里我们要知道，你为什么认识这些信号呢，记住了对应场景下的信号＋后续是有”动作“要你执行的。
Linux下的信号详解及捕捉信号
09-15
当信号产生时，它会被保存在进程的PCB（进程控制块）中，等待合适的时刻进行处理。 信号的产生主要有以下几种情况： 1. 用户在终端上按下特定键，如Ctrl+C产生SIGINT，Ctrl+\产生SIGQUIT，Ctrl+Z产生SIGTSTP。 2. ...
Linux信号详解
weixin_59371851的博客
08-31 4545
目录前言一、信号概念1、生活中的信号2、计算机中的信号 3、实现信号捕捉二、产生信号的方式1. 通过终端按键产生信号格外拓展：核心转储（core dump）status 2、调用系统函数向进程发信号3. 由软件条件产生信号 4、硬件异常产生信号三、阻塞信号1、概念 2、内核中的表示3、信号集操作函数3.1用户层函数3.2 系统接口四、信号捕获1、用户态和内核态 2、内核如何捕获进程信号2.1捕获信号过程2.2 sigaction五、函数的重入六、c语言关键字volatile总结哈喽，小伙伴们大家好，本篇文章
任意波形信号数据生成器 生成mif文件 内置正弦 锯齿 三角 方波 可手绘波形 频谱分析
04-24
能生成任意的正弦波、方波、三角波、锯齿波波形数据，还支持手绘波形和频谱分析
【Linux】信号（1）认识、记录和产生信号
m0_64645696的博客
06-23 478
当进程发生错误时，OS 会中止进程，它是如何做到的？这就需要了解一个重要的元素：信号。OS 会发出信号使得进程状态改变，比如我们常用的 kill -9、ctrl + c 等等，那么 OS 是怎么识别这些信号的，下面我们来认识一下信号。 当信号还没产生时，我们都知道信号的结果，为什么，因为我们学习了，那操作系统怎么学习呢，在产生时我们得先识别出来。且信号产生的种类有很多种情况，进程的运行和信号的产生是属于一种异步关系，也就是说，信号产生的同时不会打搅进程的运行。 当信号产生时，不一
Linux进程信号——信号的产生
ych9527的博客
04-09 3661
文章目录1.信号的概念2.通过Ctrl c分析信号2.1Ctrl c的作用2.2 signal接口2.3证明ctrl +c本质是信号2.4总结3.信号处理的常见方式4.信号的产生方式4.1通过终端按键产生4.2调用系统函数向进程发送信号4.3.1调用kill4.3.2调用rasize4.3.2.1使用演示4.3.2.2linux中9号信号不能被捕捉4.3.3调用abort4.3软件条件产生信号4.3.1使用演示4.3.2 利用alarm验证IO对效率的影响4.4硬件异常产生信号4.5总结 1.信号的概念 信
linux -- 信号
Half-up的博客
10-23 535
信号及信号来源 使用kill命令杀死进程的实质，是向目标进程发送了一个信号，当目标进程接收到这个信号后，会根据信号的处理函数，执行指 定动作。 比如：keil 杀死进程就是使用的9号信号 使用“kill-l”命令可查看系统中的信号 产生信号的五种情况： linux系统中信号的状态： linux 系统中信号的处理方式: 信号的默认动作： 信号的产生 系统调用中发送信号常用的函数有kill（）、raise（）、abort（）等，其中kill是最常用的函数，该函数的作用是给指定进程发送信号，
Linux系统编程05--信号1
xianyulajiao的博客
03-16 1255
文章目录五、信号-1信号概念信号编号信号机制信号产生的方式、种类1.终端下特殊快捷键产生信号，发送给当前shell的前台进程。2.硬件异常3.kill函数或kill命令（函数发送信号方式）4.某种软件条件触发信号信号产生运原因 五、信号-1 信号概念 信号编号 查询Linux系统信号编号表（Linux提供64个信号种类） kill -l 在当前学习Linux系统编程阶段，学习前32个信号，为Linux经典信号，后32个信号是实时信号，是硬件使用的信号。其实通过kill -l查询并没有64个信号，1-3
linux 信号产生 信号保存 信号处理
qq_53217755的博客
04-14 513
信号的产生方式四种：； 1，通过终端摁键产生的信号 2，调用系统函数产生的信号 ；例如signal() abort() kill（） 3,由软件链接产生的信号 alarm 4 硬件异常产生的信号 CPU 信号的保存 通过位图的方式 信号的处理：：： 实际执行信号的处理的动作称为信号递达 信号从产生到递达之间的状态成为信号未决 进程可以选择阻塞某个信号 被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作 注意 递达和忽略是不同的 只要信号被阻塞就不会递达，
【Linux】解析键盘组合键产生信号的完整过程：从硬件中断到信号发送
最新发布
ljh1257的博客
05-07 1207
每一个了解Linux的都知道这样一个知识，Ctrl+C组合键能够终止一个进程。然后，就去了解信号，发现存在键盘产生信号这一种方式，Ctrl+C组合键可以送2号信号SIGINT给进程，所以，上面的图片中的死循环被终止了因为进程收到了2号信号。个人对于其中的原理非常好奇，所以经过研究就有了这一篇文章。
Linux：信号的产生、记录以及处理动作
ETalien_的博客
01-17 373
信号以及信号的相关函数 信号有哪些？ Linux下一共有62个信号，0-34为普通信号（无32、33信号），35-64为实时信号。 信号是怎么产生的？ 信号是由操作系统直接或间接产生的。 信号的产生有四种情况： 通过键盘产生 比如我们不下心写了一个死循环，那么我们要终止这个死循环就会按Ctrl+c，那么Ctrl+c的本质其实就是向目标进程或是前台进程发送2号信号，键盘产生了信号，但是其实是操...
一、信号生成
weixin_51036112的博客
10-16 854
基于MATLAB的信号处理入门教程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值