linux之进程信号(初识信号，信号的产生)

目录

  • 引入
  • 一、初识信号(信号预备知识)
    • 1.生活中的信号
    • 2.Linux中的信号
    • 3.信号+进程得出的初步结论
  • 二、信号的产生
    • 1.通过终端输入产生信号
    • 拓展: 硬件中断
    • 2.调用系统函数向进程发信号
    • 3.硬件异常产生信号
    • 4.软件条件产生信号
    • 拓展: 核心转储技术
    • 总结一下：

引入

一、初识信号(信号预备知识)

1.生活中的信号

  • 当你在打着永杰无间的时候，你的外卖到了，外卖员给你打电话去取，而你此时正在打游戏，你心里想着这把打完了去取，过了一会，你打完了这把游戏，你想起来你还有外卖没取，你就马上去取了
  • 信号弹
  • 我们根据红绿灯的颜色过马路
  • 上课铃声响了，我们取上课

  1. 你怎么认识这些信号？
    有人教过我，我就记住了 -> 1.识别信号 2.知道信号的处理方法

  2. 即使我们现在没有信号产生，我们也知道信号产生之后，我该干什么？

  3. 信号产生了之后，我们可能不会立即处理这个信号，我们可能有更重要的事情要做，但是我们必须要把信号产生这个信息保存下来，在合适的时候去处理

2.Linux中的信号

概念：Linux信号通常由操作系统或其他进程发送给目标进程，可以用于多种目的，例如中断进程、终止进程或请求进程执行某个特定操作。本质是一种通信机制。

用kill -l命令可以察看系统定义的信号列表

在这里插入图片描述
可以看到全是大写的，因为linux是用c语言写的，所以就是c语言中的宏，所以我们也可以使用数字也可以使用以上宏都是一个意思
一共有62个信号，因为32、33不存在，其中，1-31是普通信号，也是本文重点讲解的， 34-64属于实时信号，优先级比较高，立即处理，本文不做讲解。

3.信号+进程得出的初步结论

所以进程信号？

  1. 进程必须识别并能够处理信号 ，信号即使没有产生。也要具备处理信号的能力，怎么做到呢？信号的处理能力，是操作系统给进程内置的功能的一部分

  2. 进程即使没有收到信号，也能知道哪些信号该如何处理

  3. 当进程真的收到了一个具体的信号的时候，进程可能并不会立即处理这个信号，会在合适的时候区里这个信号 处理动作：1.默认动作 2.忽略 3.自定义动作

  4. 一个进程必须当信号产生，到信号开始处理，就会有一定的时间窗口，这段窗口，进程需要保存哪些信号已经发送了的能力

所以信号要经历： 信号产生 -> 信号保存 -> 信号处理 三个阶段

ctrl + c 为啥能杀死我们的前台进程呢？

  • linux中，一次登录中，一般会配上一个bash，每一个登录，只允许一个进程是前台进程，可以允许多个进程是后台进程。
  • 当我们用键盘输入ctrl + c 快捷键时候，会被解释成2号信号然后发给前台进程
  • 启动进程的时候 加上 & 表示以后台进程的方式启动
  • 所以，当我们以后台进程状态运行时，我们用键盘输入ctrl + c 的时候进程收不到信号，也就不会终止进程，我们只能使用kill命令杀死该进程
    在这里插入图片描述

二、信号的产生

通过以上对linux信号的简单了解后，我们再来看一下信号是如何产生的，以下是信号产生的几种方式

1.通过终端输入产生信号

比如ctrl + c 就是2号信号SIGINT，我们如何来验证呢？
介绍一个函数

SIGNAL(2)                                                                      Linux Programmer's Manual                                                                      SIGNAL(2)NAMEsignal - ANSI C signal handlingSYNOPSIS#include <signal.h>typedef void (*sighandler_t)(int);  //函数指针sighandler_t signal(int signum, sighandler_t handler); //表示当我们收到signum信号后，处理动作为handler方法//，涉及信号处理，此处先简单讲解

实验一：

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <signal.h>
using namespace std;
//num：收到了哪个信号
void handler(int num)
{cout << num << " handler ..." << endl;//exit(1);
}
int main()
{signal(SIGINT, handler);//只需设置一次，以后都有效while(1){cout << "i am a process, mypid: " << getpid() << endl;sleep(1);}return 0;
}

在这里插入图片描述
可以看到输入的ctrl + c被转换成2号信号

其实还有一些快捷键也可以表示为信号，比如ctrl + \ 表示3号信号即SIGQUIT
实验二：
code：

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <signal.h>
using namespace std;
void handler(int num)
{cout << "signal: " <<  num << " handler ..." << endl;//exit(1);
}
int main()
{signal(SIGINT, handler);signal(3, handler);while(1){cout << "i am a process, mypid: " << getpid() << endl;sleep(1);}return 0;
}

在这里插入图片描述
我们可以发现，2号和3号信号的处理动作都是同一个函数，这也就是为handler函数要有一个参数为int，就是为了标识是哪个信号正在处理。

但是有些信号不会使用signal定义的处理动作，比如19号信号SIGSTOP
实验三：
code：

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <signal.h>
using namespace std;
void handler(int num)
{cout << "signal: " <<  num << " handler ..." << endl;//exit(1);
}
int main()
{signal(SIGINT, handler);//signal(3, handler);signal(19, handler);while(1){cout << "i am a process, mypid: " << getpid() << endl;sleep(1);}return 0;
}

在这里插入图片描述
可以看到ctrl + z 并没有调用自定义的signal方法，仍然使进程停止了，这是为什么呢？想知后续请继续往下看！

实验四：
对所有信号都实验signal捕捉

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <signal.h>
using namespace std;
void handler(int num)
{cout << "signal: " <<  num << " handler ..." << endl;//exit(1);
}
int main()
{//signal(SIGINT, handler);//signal(3, handler);//signal(19, handler);for(int i = 1; i <= 31; ++i){signal(i, handler);}while(1){cout << "i am a process, mypid: " << getpid() << endl;sleep(1);}return 0;
}

在这里插入图片描述
可以看到1-8都被捕捉了，而9号信号没有。我们继续重启进程，继续向后发信号。
在这里插入图片描述
在这里插入图片描述
可以看到10-18都被捕捉了，19不会，也就是之前做的实验三。
继续重启进程，发信号，可以发现都被捕捉了（这里不做演示了）。

所以只有9号和19号信号不会被signal捕捉，这是为什么呢？
可以发现这俩一个是杀死进程，一个是停止进程，都跟进程的执行有关，你觉得操作系统为啥不让所有信号被捕捉呢？很简单，操作系统又不是傻子，万一有个病毒软件什么的，它把所有信号都捕捉了，那它不就永远都杀不掉了嘛。

拓展: 硬件中断

看了上面的，你有什么疑问嘛？
键盘数据是如何传入给内核的？，ctrl + c 又是如何变成信号交给进程呢？
接下来就要谈谈硬件了

首先，进程是由操作系统管理的，所以键盘被按下，肯定是操作系统先知道？那么操作系统又是如何知道键盘上有数据了？？？？
在这里插入图片描述

  1. 操作系统会在启动的时候加载进内存
  2. linux下一切皆文件，每个文件都有自己的缓冲区，即struct file结构体
  3. os怎么知道键盘上有数据？os会对外设进行轮询监测嘛？os系统没这么蠢，系统中这么多设备，操作系统这样的化效率太低了
  4. cpu和键盘通过主板连接在一起，cpu上有很多针脚，和各种设备间接或直接连接着，当键盘中有数据产生的时候，键盘会给cpu发送硬件中断，将cpu特定的针脚发送高低电频，即充放电，然后cpu感受到了。
  5. cpu中的寄存器如何存储数据呢？也就是上述充放电的过程
  6. os内核中有一个中断向量表，就和文件描述符表向上，中断向量表中存储各个设备的读写方法
  7. 当键盘中有数据产生，给cpu发送硬件中断，cpu让操作系统执行中断相量表中的方法去读取键盘中的数据
  8. 当键盘中的数据是一般数据的时候，会被读入缓冲区中，当是快捷键比如ctrl + c 这样的，会被解释成信号由操作系统发送给进程

那么以上所讲硬件中断和我们讲的信号有什么联系嘛？
我们学习的信号，就是利用软件的方式，对进程模拟硬件中断

再谈缓冲区

  1. 平常我们输入命令的时候，我们可以看到我们自己的输入，其实是操作系统将键盘输入缓冲区中的数据拷贝到显示器输出缓冲区中去了，我们就可以看到我们输入的内容了，而linux中输入密码的时候我们看不到密码，也就是os没有把此时的输入缓冲区中的内容拷贝到输出缓冲区中去
  2. 当我们以后台进程的方式启动进程时，我们即使隔一段时间才输入一个完整的命令，也可以正常执行，因为我们我们看到的很长时间才输入完整的命令实在显示器缓冲区中，而输入缓冲区中的数据时连续完整的，所以可以正常执行

在这里插入图片描述

2.调用系统函数向进程发信号

在这里插入图片描述
可以看到，kill系统调用的作用是发送一个信号给指定进程，就不就是和我们命令行中的kill命令一样的嘛，其实我们命令行中的kill命令底层就是调用的kill系统调用。
那么我们直接来做一个kill命令

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <cstdio>
#include <signal.h>
using namespace std;
static void Usage(const string& cmd)
{cout << "\n\r " << cmd << " signo process_pid " << endl << endl;
}
int main(int argc, char* argv[])
{if(argc != 3){Usage(argv[0]);exit(1);}int sig = stoi(argv[1]);pid_t id = stoi(argv[2]);int ret = kill(id, sig);if(ret == -1){perror("kill");exit(2);}return 0;
}

在这里插入图片描述

在这里插入图片描述
raise作用：发送一个信号给调用者，实际上就是kill的封装，就是kill(getpid(), sig).

在这里插入图片描述
abort作用: 给调用者发送6号信号（SIGABRT，实际也是对kill的封装，但是他有一些特性，直接看实验

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <cstdio>
#include <signal.h>
using namespace std;
// static void Usage(const string& cmd)
// {
//     cout << "\n\r " << cmd << " signo process " << endl << endl;
// }
void handler(int signum)
{cout << "get a sig : " << signum << endl;
}
int main(int argc, char* argv[])
{// if(argc != 3)// {//     Usage(argv[0]);//     exit(1);// }// int sig = stoi(argv[1]);// pid_t id = stoi(argv[2]);// int ret = kill(id, sig);// if(ret == -1)// {//     perror("kill");//     exit(2);// }signal(6, handler);for(int i = 0; i < 3; ++i){cout << "i am a process pid: " << getpid() << endl;sleep(1);}abort();return 0;
}

在这里插入图片描述
可以看到，即使signal捕捉了6号信号，进程也执行了handler方法，但进程最终还是终止了，所以abort内部采用一定的手段使进程强制停止了。

3.硬件异常产生信号

1.除0错误
code：

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <cstdio>
#include <signal.h>
using namespace std;void handler(int signum)
{cout << "get a sig : " << signum << endl;
}
int main()
{// signal(SIGFPE, handler);cout << "zero before" << endl;sleep(1);int a = 10;cout << 10 / 0 << endl;;cout << "zero after" << endl;return 0;
}

实验现象：
在这里插入图片描述
放开注释后，自定义捕捉SIGFPE信号

实验现象：
在这里插入图片描述
可以看到我们捕捉了8号信号（SIGFPE），所以发生除0错误后，会收到8号信号，但是我们一直死循环重复捕捉，这是为什么呢？

  • 我们从硬件角度来分析，cpu内有一套寄存器，保存着进程的上下文数据，其中一些特殊的寄存器比如eip/pc记录着进程执行的代码情况。
  • 最重要的是有一个状态寄存器，他就是一个位图结构，用来记录进程的运行状态。每一个比特位代表不同的状态。
  • 当发生除0错误的时候，状态寄存器中溢出标记位由0变1，发生异常。
  • 而操作系统是硬件的管理者，它发现cpu中状态寄存器发生异常，就会给进程发送特定的信号，而进程本身无法处理这个异常，即使捕捉了信号， 操作系统就会不断的发信号。

2.野指针异常
code：

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <cstdio>
#include <signal.h>
using namespace std;void handler(int signum)
{cout << "get a sig : " << signum << endl;
}int main()
{//signal(SIGSEGV, handler);cout << "before" << endl;sleep(1);int *p = nullptr;*p = 30;cout << "after" << endl;return 0;
}

实验现象：
在这里插入图片描述
放开注释，实验现象：
在这里插入图片描述
可以看到，发生野指针的时候，也会不断收到信号。
我们再从底层的角度解释一下：

  • 发生野指针的本质是访问无效的空间，由进程地址空间可以知道，我们语言上访问的空间其实是虚拟地址，实际上我们要通过页表进行虚拟地址到物理地址的转化，而这一过程os系统不会参与，会有页表和mmu(memory manager unit)即内存管理单元（cpu中硬件），当转化失败的时候mmu会报错。
  • os系统是硬件的管理者，它识别到mmu的报错，而进程无法修正错误，即使捕捉了信号，就不断给进程发信号

总结一下：
当我们出现异常的时候，操作系统为啥选择给进程发信号，然后去执行特定的代码，而不是直接干掉进程呢？
其实向我们发信号是为了让进程知道进程出现了什么异常，而且让进程有一定的缓存时间，去处理日志信息等，如果操作系统直接把进程干掉了，就可能处理不了这些情况了。

补充：
上述过程一个进程导致cpu中的寄存器发生了异常，也就是硬件发生了异常，为啥其他进程还能正常运行呢？

  • cpu中的寄存器只有一套，存储的是进程的上下文信息，当发生进程切换的时候，进程会带走它的上下文数据，然后其他进程将它之前访问的上下文数据放进寄存器，上一个进程带来的寄存器异常已经被带走了，而新来的进程上下文数据并没有异常，所以不会影响其他进程的运行。
  • 所以信号的存在不是让我们解决问题，操作系统都解决不了，你让进程自己解决码？
  • 信号的存在是为了让我们知道程序异常的原因，并且给我们一定的缓冲时间，用来打印日志信息等等。

4.软件条件产生信号

比如我们写管道的时候，当读端关闭的时候，写端还有继续写入，此时操作系统就会向写端进程发送SIGPIPE信号，然后终止进程。
在这里插入图片描述
调用alarm函数可以设定一个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动作是终止当前进程。
返回值代表上次设定闹钟的剩余时间，比如你定一个闹钟30分钟后响，20分钟后你就行了，此时你查看时间闹钟还有10分钟才响。

实验：如果我们自定义处理闹钟的动作，进行一些日志打印等操作，然后再在捕捉函数内定一个闹钟，不就做到了不断做日志打印的业务了嘛？
code：

#include <signal.h>
using namespace std;
void work()
{cout << "print a log..." << endl;
}
void handler(int signum)
{cout << "get a sig : " << signum << endl;work();alarm(5);
}
int main()
{signal(SIGALRM, handler);alarm(5);while(1){cout << "i am a process pid : " << getpid() << endl;sleep(1);}return 0;
}

实验现象：
在这里插入图片描述

返回值验证：可以看到上面实验现象每次闹钟剩余时间都是0，因为我们没有利用其他手段让闹钟提前苏醒，我们使用kill命令来验证
实验现象：
在这里插入图片描述
补充：

  • 操作系统内部有很多进程，每个进程都可以设置闹钟，那么操作系统内部就有很多闹钟了，操作系统就要管理它们，管理的本质是先描述再组织，用特定的结构体来描述闹钟，比如 struct alarm.
  • struct alarm中需要存储设置这个alarm的进程，以及什么时候响，一般用当前时间戳+设计多久响来表示
  • 那么操作系统用什么组织alarm呢？很明显可以用我们常见的数据结构小堆来管理，堆顶存最早响的闹钟，os只需要查看堆顶的时间，如果超时了，给struct alarm中存的进程pid发送信号，然后将堆顶的数据删除，继续查看堆顶，重复以上动作，直到堆顶没有超时。

拓展: 核心转储技术

在这里插入图片描述
之前讲进程退出状态的时候，正常退出时次第8为为退出码，低8位为0，
收到信号退出的时候，次第0位无意义，低7位表示退出信号，其中第8个比特位之前没有讲，其实是core dump（核心转储）标识。

什么是核心转储？
将进程异常退出时的状态保存下来形成一个core.pid文件，放在当前路径下（磁盘）可以配合gdb进行时候调试，一会做实验。

一般在项目上线后是关闭的，为什么？
一般服务即使出现异常挂掉了，会有一定的手段自动重启，如果一些程序员写的代码太水，一上线就挂掉，不断自动重启，不断形成core dump文件，把磁盘写满，挂的就是操作系统了，那问题就严重了。

并不是所以的信号都会使进程挂掉后形成核心转储，通过man 7 signal可以查看
在这里插入图片描述
其中term表示只终止进程，core表示终止进程并形成core dump核心转储文件。
ign表示忽略动作，stop表示停止，这俩现在不详细讲。

实验验证：

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstdio>
#include <signal.h>
using namespace std;int main()
{pid_t id = fork();if(id == 0){int cnt = 500;while(cnt){cout << "i am child process, pid: " << getpid() << "cnt: " << cnt-- << endl;sleep(1);}exit(0);}int status = 0;pid_t rid = waitpid(id, &status, 0);cout << " child quit info, rid: " << rid << " exit code: " << ((status >> 8) & 0xff) << " exit signal: " << (status & 0x7f) << " core dump: " << (status >> 7 & 1) << endl;return 0;
}

默认情况下core dump是关闭的，ulimit -a可以查看
在这里插入图片描述
此时实验现象：
在这里插入图片描述
在这里插入图片描述
可以看到此时无论发送term信号还是core信号都不会形成core dump。

当我们把核心转储打开
在这里插入图片描述
开始重做实验：
在这里插入图片描述
在这里插入图片描述
可以看到当我们使用core信号时，形成了核心转储文件，并且很大。

那么我们如何将他和gdb配合使用呢？
code：

#include <iostream>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <cstdio>
#include <signal.h>
using namespace std;int main()
{int a = 10;a /= 0;cout << "a: " << a << endl;return 0;
}

在这里插入图片描述
当我们直接运行的时候，可以看到报错多了一段core dumped，并形成了core.pid文件
在这里插入图片描述
直接开始gdb
在这里插入图片描述
可以看到直接定位到了异常的位置

总结一下：

  1. 上面所说的所有信号产生，最终都要有OS来进行执行，为什么？
    OS是进程的管理者

  2. 信号的处理是否是立即处理的？
    普通在合适的时候进行处理，但是对于实时信号来说，必须立马处理。

  3. 信号如果不是被立即处理，那么信号是否需要暂时被进程记录下来？记录在哪里最合适呢？
    可以发现普通信号一共有31个，一个int有32个比特位，不觉得很巧嘛？每一个比特位代表着一个信号，0和1表示着是否收到该信号，其实信号就是用类似这样的结构保存的，也就是位图，但是可以发现只能存0和1那就只能表示是否收到该信号，而不能知道收到该信号的数量的，实际上内核也是这样的。
    而实时信号需要立即处理，所以发几个信号就要处理几个，所以就不能用位图结构来存储了，而是用一个队列（先到先处理）。

  4. 一个进程在没有收到信号的时候，能否能知道，自己应该对合法信号作何处理呢？
    必须知道。

  5. 如何理解OS向进程发送信号？能否描述一下完整的发送处理过程？
    与其说os向进程发信号，不如说向进程的pcb发信号，信号在pcb中用位图方式存储，那么os向进程发信号就是修改进程pcb中的位图，将对应的信号比特位由0置1.

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/67368.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【工具类】获取日出日落时间的Java工具类

【工具类】获取日出日落时间的Java工具类

博主介绍&#xff1a;✌全网粉丝22W&#xff0c;CSDN博客专家、Java领域优质创作者&#xff0c;掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域✌ 技术范围&#xff1a;SpringBoot、SpringCloud、Vue、SSM、HTML、Nodejs、Python、MySQL、PostgreSQL、大数据、物…
阅读更多...
Open FPV VTX开源之betaflight配置

Open FPV VTX开源之betaflight配置

Open FPV VTX开源之betaflight配置 1. 源由2. 配置3. 总结4. 参考资料5. 补充 - 飞控固件版本 1. 源由 飞控嵌入式OSD - ardupilot配置使用betaflight配套OSD图片。 Choose correct font depending on Flight Controller SW. ──> /usr/share/fonts/├──> font_btfl…
阅读更多...
Python从0到100（八十三）：神经网络-使用残差网络RESNET识别手写数字

Python从0到100（八十三）：神经网络-使用残差网络RESNET识别手写数字

前言： 零基础学Python：Python从0到100最新最全教程。 想做这件事情很久了，这次我更新了自己所写过的所有博客，汇集成了Python从0到100，共一百节课，帮助大家一个月时间里从零基础到学习Python基础语法、Python爬虫、Web开发、 计算机视觉、机器学习、神经网络以及人工智能…
阅读更多...
docker安装和测试redis步骤

docker安装和测试redis步骤

docker安装和测试redis步骤 一、官方推荐安装方式&#xff1a; 1、执行 docker pull redis:4.0.1 命令&#xff0c;下载 redis 镜像&#xff0c;如下所示&#xff1a; 2、执行命令&#xff0c;创建并启动redis容器 docker run - -rm -d - -name redis6379 -p 6379:6379 r…
阅读更多...
微信小程序原生与 H5 交互方式

微信小程序原生与 H5 交互方式

在微信小程序中&#xff0c;原生与 H5 页面&#xff08;即 WebView 页面&#xff09;之间的交互通常有以下几种方式&#xff1a; 1. 使用 postMessage 进行通信 微信小程序的 WebView 页面和原生小程序页面可以通过 postMessage 来进行数据传递。 WebView 页面向原生小程序发…
阅读更多...
vue3学习日记5 - 项目起步

vue3学习日记5 - 项目起步

最近发现职场前端用的框架大多为vue&#xff0c;所以最近也跟着黑马程序员vue3的课程进行学习&#xff0c;以下是我的学习记录 视频网址&#xff1a; Day2-11.项目起步-静态资源引入和ErrorLen安装_哔哩哔哩_bilibili 学习日记&#xff1a; vue3学习日记1 - 环境搭建-CSDN博…
阅读更多...
计算机组成原理--笔记一

计算机组成原理--笔记一

目录 一.计算机硬件的基本组成 1.早期冯诺依曼机的结构 2.现代计算机的结构 二.各个硬件的工作原理 1.主存储器 i. 读取数据 ii. 写入数据 1.1 基本组成 2.运算器 3.控制器 一.计算机硬件的基本组成 1.早期冯诺依曼机的结构 “存储程序”&#xff0c;将指令以二进制的形式输入…
阅读更多...
漫话架构师|什么是系统架构设计师（开篇）

漫话架构师|什么是系统架构设计师（开篇）

~犬&#x1f4f0;余~ “我欲贱而贵&#xff0c;愚而智&#xff0c;贫而富&#xff0c;可乎&#xff1f; 曰&#xff1a;其唯学乎” 关注犬余&#xff0c;共同进步 技术从此不孤单
阅读更多...
CV(10)--目标检测

CV(10)--目标检测

前言 仅记录学习过程&#xff0c;有问题欢迎讨论 目标检测 object detection&#xff0c;就是在给定的图片中精确找到物体所在位置&#xff0c;并标注出物体的类别;输出的是分类类别label物体的外框&#xff08;x, y, width, height&#xff09;。 目标检测算法&#xff1a…
阅读更多...
【Qt】01－了解QT

【Qt】01－了解QT

踏入QT的殿堂之路 前言一、创建工程文件1.1 步骤介绍1.2 编译介绍方法1、方法2、编译成功 二、了解框架2.1 main.cpp2.2 .Pro文件2.2.1 注释需要打井号。2.2.2 F1带你进入帮助模式2.2.3 build文件 2.3 构造函数 三、编写工程3.1 main代码3.2 结果展示 四、指定父对象4.1 main代…
阅读更多...
【深度学习】关键技术-激活函数（Activation Functions）

【深度学习】关键技术-激活函数（Activation Functions）

激活函数&#xff08;Activation Functions&#xff09; 激活函数是神经网络的重要组成部分&#xff0c;它的作用是将神经元的输入信号映射到输出信号&#xff0c;同时引入非线性特性&#xff0c;使神经网络能够处理复杂问题。以下是常见激活函数的种类、公式、图形特点及其应…
阅读更多...
3.flask蓝图使用

3.flask蓝图使用

构建一个目录结构 user_oper.py from flask import Blueprint, request, session, redirect, render_template import functools # 创建蓝图 user Blueprint(xkj, __name__)DATA_DICT {1: {"name": "张三", "age": 22, "gender": …
阅读更多...
React第二十二章(useDebugValue)

React第二十二章(useDebugValue)

useDebugValue useDebugValue 是一个专为开发者调试自定义 Hook 而设计的 React Hook。它允许你在 React 开发者工具中为自定义 Hook 添加自定义的调试值。 用法 const debugValue useDebugValue(value)参数说明 入参 value: 要在 React DevTools 中显示的值formatter?:…
阅读更多...
【漏洞分析】DDOS攻防分析

【漏洞分析】DDOS攻防分析

0x00 UDP攻击实例 2013年12月30日&#xff0c;网游界发生了一起“追杀”事件。事件的主角是PhantmL0rd&#xff08;这名字一看就是个玩家&#xff09;和黑客组织DERP Trolling。 PhantomL0rd&#xff0c;人称“鬼王”&#xff0c;本名James Varga&#xff0c;某专业游戏小组的…
阅读更多...
【 PID 算法 】PID 算法基础

【 PID 算法 】PID 算法基础

一、简介 PID即&#xff1a;Proportional&#xff08;比例&#xff09;、Integral&#xff08;积分&#xff09;、Differential&#xff08;微分&#xff09;的缩写。也就是说&#xff0c;PID算法是结合这三种环节在一起的。粘一下百度百科中的东西吧。 顾名思义&#xff0c;…
阅读更多...
PyTorch使用教程(1)—PyTorch简介

PyTorch使用教程(1)—PyTorch简介

PyTorch是一个开源的深度学习框架&#xff0c;由Facebook人工智能研究院&#xff08;FAIR&#xff09;于2016年开发并发布&#xff0c;其主要特点包括自动微分功能和动态计算图的支持&#xff0c;使得模型建立更加灵活‌。官网网址&#xff1a;https://pytorch.org。以下是关于…
阅读更多...
PyTorch框架——基于深度学习YOLOv5神经网络水果蔬菜检测识别系统

PyTorch框架——基于深度学习YOLOv5神经网络水果蔬菜检测识别系统

基于深度学习YOLOv5神经网络水果蔬菜检测识别系统&#xff0c;其能识别的水果蔬菜有15种&#xff0c;# 水果的种类 names: [黑葡萄, 绿葡萄, 樱桃, 西瓜, 龙眼, 香蕉, 芒果, 菠萝, 柚子, 草莓, 苹果, 柑橘, 火龙果, 梨子, 花生, 黄瓜, 土豆, 大蒜, 茄子, 白萝卜, 辣椒, 胡萝卜,…
阅读更多...
Mac玩Steam游戏秘籍！

Mac玩Steam游戏秘籍！

Mac玩Steam游戏秘籍&#xff01; 大家好&#xff01;最近有不少朋友在用MacBook玩Steam游戏时遇到不支持mac的问题。别担心&#xff0c;我来教你如何用第三方工具Crossover来畅玩这些不支持的游戏&#xff0c;简单又实用&#xff01; 第一步&#xff1a;下载Crossover 首先&…
阅读更多...
【网络篇】IP知识

【网络篇】IP知识

IPv4首部与IPv6首部 IPv4相对于IPv6的好处&#xff1a; 1.IPv6可自动配置&#xff0c;即使没有DHCP服务器也可以实现自动分配IP地址&#xff0c;实现即插即用。 2.IPv6包首部长度采用固定40字节&#xff0c;删除了选项字段&#xff0c;以及首部校验和&#xff0c;简化了首部…
阅读更多...
我的年度总结

我的年度总结

这一年的人生起伏&#xff1a;从曙光到低谷再到新的曙光 其实本来没打算做年度总结的&#xff0c;无聊打开了帅帅的视频&#xff0c;结合自己最近经历的&#xff0c;打算简单聊下。因为原本打算做的内容会是一篇比较丧、低能量者的呻吟。 实习生与创业公司的零到一 第一段工…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023