Linux---进程信号

一、信号的概念

 信号是一种向目标进程发送通知消息的机制

信号的特性(可以结合红绿灯、防空警报等生活样例来理解)

1、在信号没有出现之前，我们就已经知道如何去处理信号，即我们认识信号

2、信号是异步产生的，即我们不知道它具体何时产生

3、当信号产生时，我们可以对它暂时忽略不做处理(比如我们外卖到了，但是你正在和朋友开黑，就会将外卖暂时搁置)

4、由于我们有时不会立即去执行信号，所以我们需要能储存信号

信号列表如下

一些补充的知识

二、信号的产生

 1、通过键盘进行信号的产生

解释如下

该系统调用接口可以自定义捕捉信号的行为，将signum信号的默认行为改为handler

//process.cc
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>void handler(int signo)
{std::cout<<"发送了一个2号信号"<<std::endl;exit(1);
}int main()
{signal(2,handler);std::cout << "pid: " << getpid() << std::endl;while(1){std::cout << "running" << std::endl;sleep(1);}return 0;
}

对信号的进一步理解

 man 7 singal  查看信号的默认行为

既然我们能通过signal系统调用将信号的默认方法改变，那么我们能否将所有能杀死进程的信号改掉，使得进程无法被终止呢？？？

 很显然是不行的，有些信号是无法被自定义捕捉，比如9号信号，保证了OS的安全

2、通过系统调用进行信号的产生

功能：向pid进程发送sig信号（kill命令就是调用的该系统调用）

举个例子(写一个自己的kill命令)

//test.c
#include <stdio.h>
#include <unistd.h>
int main()
{printf("%d\n",getpid());while(1){printf("running\n");sleep(1);}return 0;
}//mykill.cc
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>int main(int argc,char* argv[])
{if(argc!=3){std::cout<<"\nUsage:" << argv[0] <<" -signnumber processid" << std::endl;return 0;}int signnumber = std::stoi(argv[1]+1);int pid = std::stoi(argv[2]);kill(pid, signnumber);return 0;
}

功能：向本进程发送sig信号

举个例子

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>void handler(int signo)
{std::cout<<"发送了一个" << signo <<"号信号"<<std::endl;
}int main()
{signal(2,handler);while(1){raise(2);sleep(1);}return 0;
}

功能：向本进程发送6号信号，且进程一定会终止

举个例子

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>void handler(int signo)
{std::cout<<"发送了一个" << signo <<"号信号"<<std::endl;
}int main()
{std::cout << getpid() << std::endl;signal(6,handler);// abort();while(1){std::cout << "running" << std::endl;sleep(1);}return 0;
}

3、通过硬件异常进行信号的产生

原理如下

那么除0异常是发送的哪个信号呢？是8号信号，验证如下

根据上图：发送的确实是8号信号，但现在还有一个问题，进程出异常，OS发送8号信号，可以理解，但是为什么它一直在打印呢，明明我的代码没有循环啊？

因为，原本的8号信号被自定义捕捉成了打印语句，导致进程无法退出，所以进程依旧会在等待队列中等待CPU调度，所以各种寄存器中存放的该进程相关的数据(即进程上下文)都会被保留，包括状态寄存器，而一旦该进程被调度，那么OS就又会检测到硬件错误，向进程发送8信号，如此反复，故有上面的现象发生。

(一旦进程退出，它的相关数据就会被丢弃，因为我们不在需要调度该进程了)

OS杀死进程，就是处理问题的方式之一

程序运行出现异常，如何做取决于用户，但一般都是要让进程退出的（注意：异常的处理，很多时候只是打印错误）

顺便说一下，*nullptr发送的信号是11号信号，本质是页表中没有该地址的物理地址的映射关系，引发的硬件错误

4、通过软件条件进行信号的产生

这个其实在之前的博客中就讲过一些示例，比如管道中只要读端关闭，写端还在写，OS就会向写端发送SIGPIPE，终止写端，它本质是因为OS的内核数据中发现该管道只被一个进程打开，所以发信号终止写端，不是硬件异常，而是软件条件产生的信号。又比如调试程序用的gdb向进程发送的SIGSTOP和SIGCONT都是软件条件产生的信号。

这里再介绍一个alarm函数

#include <unistd.h>
unsigned int alarm(unsigned int seconds);
调用alarm函数可以设定一个闹钟，也就是告诉内核在seconds秒之后给当前进程发送SIGALRM信号(14号信号)，该信号的默认处理动作是终止当前进程

 演示如下

上面两段代码都是设置了1秒的闹钟，确实时间到了，进程就终止了，但是两段代码cnt++的运行次数却是天差地别，唯一的区别就是有没有与外设进行IO交互，也证明了IO的效率很低

 

多次使用alarm函数，就是刷新闹钟，并返回之前闹钟剩余的时间，注意：alarm(0)不是设置0秒的闹钟，这个相当于清空之前的闹钟并返回之前闹钟剩余的时间

了解(扩展)---帮助理解alarm

这里讲讲alarm是如何实现的，首先每个进程都能设置闹钟，也就是说OS中可以存在多个闹钟，所以需要管理，即先描述在组织，所以我们要设计一个闹钟结构体，里面包含闹钟所属进程id，时间（用时间戳记录）等等（根据需求往里面加属性）。然后就是如何组织，即选择什么样的数据结构进行管理，这里可以选择用小堆，按照时间大小存放，如果时间堆顶闹钟的时间没到，说明所有的都没到，不做处理，如果时间到了，就拿出来处理。(当然这不一定是Linux中alarm的实现，这里只是提供思想，具体如何实现得根据需求)

core dump(核心转储) 

介绍：

分析core dump是Linux应用程序调试的一种有效方式，core dump又称为“核心转储”，是该进程实际使用的物理内存的“快照”。分析core dump文件可以获取应用程序崩溃时的现场信息，如程序运行时的CPU寄存器值、堆栈指针、栈数据、函数调用栈等信息。

Core dump是Linux基于信号实现的。Linux中信号是一种异步事件处理机制，每种信号都对应有默认的异常处理操作，默认操作包括忽略该信号（Ignore）、暂停进程（Stop）、终止进程（Terminate）、终止并产生core dump（Core）等

这里也简单说一下，为什么有的信号终止进程需要核心转储，而有的不需要？

我们可以看一下那些不需要核心转储的终止信号，如SIGKILL，它其实并不是进程出现异常而将进程杀死，更类似于用户强制终止进程，也就是说进程本身并没有问题(或者出错原因很明显)，所以我们不需要core dump再去分析异常，但是像SIGSEGV信号，即段错误信号，我们只能知道是内存出现问题，但是具体是数组越界还是其他什么问题引发的我们并不清楚，所以我们需要core dump帮助我们去分析。

但其实通过上面我们的示例代码和结果截图，我们会发现，Term/Core的功能好像都一样，只是终止进程，并没有产生core dump文件，这是什么原因呢？

因为核心转储的文件太大了，我们用的是服务器，默认将core dump大小设置为0，即不生成核心转储，防止服务器被写满（虚拟机应该是开启的）当然可以通过指令打开，如下

注意：核心转储只能在对应的shell中生成，即哪个shell设置了core dump的大小，哪个shell跑程序收到异常才会生核心转储文件

上面的短短5行代码，就需要生成55万字节的文件，如果代码在多一点，文件只会更大，所以为了保证服务的安全，系统默认将core dump文件大小设置为0

那么核心转储的文件有什么用呢？

三、信号存储

信号的相关概念

  • 实际执行信号的处理动作称为信号递达(Delivery)
  • 信号从产生到递达之间的状态，称为信号未决(Pending)---即在信号位图中
  • 进程可以选择阻塞 (Block )某个信号---未决之后，暂时不递达

被阻塞的信号产生时将保持在未决状态，直到进程解除对此信号的阻塞，才执行递达的动作
注意：阻塞和忽略是不同的，只要信号被阻塞就不会递达，而忽略是在递达之后可选的一种处理动作

如何在OS中体现上面说的三个概念---递达、未决、阻塞？？

  • 每个信号都有两个标志位分别表示阻塞(block)和未决(pending)，还有一个函数指针表示处理动作。信号产生时，内核在进程控制块中设置该信号的未决标志，直到信号递达才清除该标志。在上图的例子中，SIGHUP信号未阻塞也未产生过，当它递达时执行默认处理动作。
  • SIGINT信号产生过，但正在被阻塞，所以暂时不能递达。虽然它的处理动作是忽略，但在没有解除阻塞之前不能忽略这个信号，因为进程仍有机会改变处理动作之后再解除阻塞。
  • SIGQUIT信号未产生过，一旦产生SIGQUIT信号将被阻塞，它的处理动作是用户自定义函数sighandler。如果在进程解除对某信号的阻塞之前这种信号产生过多次，将如何处理?POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。不讨论实时信号

四、信号阻塞

sigset_t

未决和阻塞标志可以用相同的数据类型sigset_t来存储，sigset_t称为信号集，这个类型可以表示每个信号的“有效”或“无效”状态，在阻塞信号集中“有效”和“无效”的含义是该信号是否被阻塞，而在未决信号集中“有效”和“无效”的含义是该信号是否处于未决状态。阻塞信号集也叫做当前进程的信号屏蔽字(Signal Mask)，这里的“屏蔽”应该理解为阻塞而不是忽略

信号集操作函数

int sigemptyset(sigset_t *set);将所有信号的对应bit清零，表示该信号集不包含任何有效信号
int sigfillset(sigset_t *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);用于判断一个信号集的有效信号中是否包含某种信号，若包含则返回1，不包含则返回0，出错返回-1

注意：在使用sigset_ t类型的变量之前，一定要调用sigemptyset或sigfillset做初始化，使信号集处于确定的状态

 sigprocmask

功能介绍：如果oset是非空指针，则读取进程的当前信号屏蔽字通过oset参数传出。如果set是非空指针，则更改进程的信号屏蔽字，参数how指示如何更改。假设当前的信号屏蔽字为mask，下表说明了how参数的可选值

SIG_BLOCKset包含我们希望添加到当前信号屏蔽字的信号，相当于mask = mask|set
SIG_UNBLOCKset包含我们希望从当前信号屏蔽字中解除阻塞的信号，相当于mask = mask&~set
SIG_SETMASK设置当前信号屏蔽字为set所指向的值，相当于mask=set

如果调用sigprocmask解除了对当前若干个未决信号的阻塞，则在sigprocmask返回前，至少将其中一个信号递达

演示如下

当然可能有人会说，既然能屏蔽信号，我们能不能将所有的信号全部屏蔽？？？

当然不行，跟有些信号无法被自定义捕捉是一个道理，如9号信号，这里就不验证了

 sigpending

读取当前进程的未决信号集，通过set参数传出。调用成功则返回0，出错则返回-1

演示从阻塞到递达的过程，如下

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>void handler(int signo)
{std::cout << "接收到" << signo << "信号" << std::endl;
}void Printf_Pending(const sigset_t &pending)
{for (int i = 31; i >= 1; i--){if (sigismember(&pending, i))std::cout << 1;elsestd::cout << 0;}std::cout << "\n";
}int main()
{std::cout << "pid: " << getpid() << std::endl;signal(2, handler);sigset_t set;sigemptyset(&set);sigaddset(&set, 2);sigprocmask(SIG_BLOCK, &set, nullptr); // 屏蔽2号信号std::cout << "屏蔽了2号信号" << std::endl;int cnt = 0;while (1){sigset_t pending;sigpending(&pending);Printf_Pending(pending);sleep(1);cnt++;if (cnt == 10){std::cout << "解除对2号信号的阻塞" << std::endl;sigprocmask(SIG_UNBLOCK, &set, nullptr);}}return 0;
}

这里有一个问题：pending位图的置0操作和信号的递达，谁先发生？？？

我们可以在handler方法中打印pending位图，如果已经为0，则置0操作先发生，反之，相反

显然，我们是先将pending位图的对应信号比特位置0，在执行信号的递达操作

五、信号的捕捉

信号在什么时候被处理？

--- 进程从内核态返回用户态的时候，进行信号的检测和递达

  • 用户态是一种受控的状态，能够访问的资源是有限的
  • 内核态是一种OS的共工作状态，能访问大部分系统资源

系统调用的背后，就包含了身份的变化！！！

补充一些进程地址空间的内容

内核空间对应的页表和OS资源只需要一份，因为所有的进程都需要，就像动态库资源我们只要加载一份就行，需要的就去映射。所以CPU在任何时间都能访问OS

可能有人会觉得：如果我的程序中只是在死循环的打印语句，没有进行系统调用，那么信号是不是就被处理了？

当然不是，进程是要被OS调度切换的，而当进程被放在CPU上执行时，本质就已经完成了从OS(内核)到用户的转换，所以信号有无数次机会被检测处理

Sigaction

#include <signal.h>
int sigaction(int signo，const struct sigaction *act，struct sigaction *oact);

  • 功能：可以读取和修改与指定信号相关联的处理动作。调用成功返回0，出错返回-1
  • 参数：signo是指定信号的编号。若act指针非空，则根据act修改该信号的处理动作。若oact指针非空，则通过oact传出该信号原来的处理动作。act和oact指向sigaction结构体

（只关注被框出来的两个成员）

将sa_handler赋值为常数SIG_IGN表示忽略信号，赋值为常数SIG_DFL表示执行系统默认动作，赋值为一个函数指针表示用自定义函数捕捉信号。和signal函数的第二个参数类似

当某个信号的处理函数被调用时，内核自动将当前信号加入进程的信号屏蔽字，当信号处理函数返回时自动恢复原来的信号屏蔽字，这样就保证了在处理某个信号时，如果这种信号再次产生，那么它会被阻塞到当前处理结束为止。 如果在调用信号处理函数时，除了当前信号被自动屏蔽之外，还希望自动屏蔽另外一些信号，则用sa_mask字段说明这些需要额外屏蔽的信号，当信号处理函数返回时自动恢复原来的信号屏蔽字。sa_flags字段包含一些选项，这里我们不关心所以把sa_flags设为0，sa_sigaction是实时信号的处理函数

演示如下

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
void Printf_Pending(const sigset_t &pending)
{for (int i = 31; i >= 1; i--){if (sigismember(&pending, i))std::cout << 1;elsestd::cout << 0;}std::cout << "\n";
}void handler(int signo)
{std::cout << "接收到" << signo << "信号" << std::endl;while (1){sigset_t pending;sigpending(&pending);Printf_Pending(pending);sleep(1);}
}int main()
{std::cout << "pid: " << getpid() << std::endl;struct sigaction act, oact;act.sa_handler = handler;sigemptyset(&act.sa_mask);sigaddset(&act.sa_mask, 3);sigaction(2, &act, &oact);while (1)sleep(1);return 0;
}

显然，sigaction函数不仅将自定义捕捉的2号信号在运行时自行屏蔽，而且可以通过sa_mask同时将其他的信号也屏蔽，注意这些屏蔽会在2号信号处理结束返回后解除

并且返回后，它还是会去检测是否有信号需要被递达，至于信号被处理的顺序和信号优先级有关(这里就不演示了)

 六、信号的补充问题(了解)

可重入函数

即可以重复进入的函数，什么意思？举个简单的例子，我们学过用fork创建子进程，当父进程和子进程同时执行printf语句时，就有可能在屏幕上出现交替打印的情况，导致输出的数据不符合预期，这就说明printf语句是不可重入函数。反之，如果多个执行流可以同时进入一个函数，且不发生错误，就是可重入函数。

注意：可重入和不可重入是函数的一个特征，并不能作为评判函数好坏的标准。一般来说，使用公共资源的函数都是不可重入函数。

 volatile---保持内存的可见性

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
int flag = 0;
void handler(int sigo)
{flag = 1;std::cout << "flag changed to :" << flag << std::endl;
}int main()
{signal(2, handler);std::cout << "flag:" << flag << std::endl;while (!flag);std::cout << "flag:" << flag << std::endl;return 0;
}

如果是正常编译程序，不会有问题，一旦优化(相当于release版)就会出bug为什么？

因为flag变量被优化后直接放到了CPU的寄存器中，在信号处理时，我们改变的flag是内存中的flag，并不会改变寄存器中的flag，所以进程无法结束

我们可以给flag加volatile关键字，保证内存的可见性，即保证该变量一直从内存中读取得到

SIGCHLD信号(17号信号)

子进程在终止时会给父进程发SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自 定义SIGCHLD信号的处理函数，这样父进程只需专心处理自己的工作，不必关心子进程了,子进程终止时会通知父进程，父进程在信号处理函数中调用wait清理子进程即可

1、验证子进程终止是否会向父进程发送SIGCHLD信号

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <wait.h>
#include <sys/types.h>void handler(int signo)
{std::cout << "get " << signo << " sign" << std::endl;
}int main()
{signal(SIGCHLD, handler);pid_t id = fork();if(id==0){std::cout<<"child running"<<std::endl;sleep(5);exit(1);}wait(nullptr);return 0;
}

2、在handler函数中回收子进程

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <wait.h>
#include <sys/types.h>void handler(int signo)
{std::cout << "get " << signo << " sign" << std::endl;wait(nullptr);
}int main()
{signal(SIGCHLD, handler);std::cout << "father pid: " << getpid() << std::endl;pid_t id = fork();if (id == 0){std::cout << "child pid: " << getpid() << std::endl;std::cout << "child running" << std::endl;sleep(5);exit(1);}return 0;
}

上面的是针对只有一个子进程的情况，但是如果有多个进程呢？

我们知道如果多个子进程同时退出，发送17号信号，父进程的pending表只会记录一次17号信号，也就只会执行一次wait函数，所以有的子进程就会处于僵尸状态，那我们该如何做？

有人可能觉得用循环就行，如下

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>void handler(int signo)
{std::cout << "get " << signo << " sign" << std::endl;pid_t id;while ((id = wait(nullptr))){std::cout << "child pid: " << id << " exit" << std::endl;if (id < 0)break;}
}int main()
{signal(SIGCHLD, handler);for (int i = 0; i < 5; i++){pid_t id = fork();if (id == 0){std::cout << "child is running" << std::endl;sleep(5);exit(1);}}while(1) sleep(1);return 0;
}

事实证明也确实行，但是这是所有子进程都结束的情况，如果有一部分子进程终止，另一部分子进程一直在运行，那么我们就无法跳出循环，因为wait是阻塞等待，它可以去查看是否有进程还没终止，这样就会一直在阻塞。

所以用非阻塞等待才是最恰当的，如下

void handler(int signo)
{std::cout << "get " << signo << " sign" << std::endl;pid_t id;while ((id = waitpid(-1, nullptr, WNOHANG)) > 0){std::cout << "child pid: " << id << " exit" << std::endl;}
}

当然，如果不关心子进程的返回信息，也可以直接忽略该信号，子进程会自动被清理。如下

#include <iostream>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
int main()
{signal(SIGCHLD, SIG_IGN);for (int i = 0; i < 5; i++){pid_t id = fork();if (id == 0){std::cout << "child is running" << std::endl;sleep(5);exit(1);}}while(1) sleep(1);return 0;
}

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

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

相关文章

基于MQTT协议实现微服务架构事件总线

基于MQTT协议实现微服务架构事件总线

一、场景描述 昨天在博客《客户端订阅服务端事件的实现方法》中提出了利用websocket、服务端EventEmitter和客户端mitt实现客户端订阅服务端事件&#xff0c;大大简化了客户端对服务端数据实时响应的逻辑。上述方案适用于单服务节点的情形。 对于由服务集群支撑的微服务架构&…
阅读更多...
Redis 之七：穿透、击穿、雪崩

Redis 之七：穿透、击穿、雪崩

&#xff08;本内容部分来自知乎网等网络&#xff09; Redis 缓存的使用&#xff0c;极大的提升了应用程序的性能和效率&#xff0c;特别是数据查询方面。但同时&#xff0c;它也带来了一些问题。其中&#xff0c;最要害的问题&#xff0c;就是数据的一致性问题&#xff0c;从严…
阅读更多...
Educational Codeforces Round 132 (Rated for Div. 2) E. XOR Tree（启发式合并+贪心）

Educational Codeforces Round 132 (Rated for Div. 2) E. XOR Tree（启发式合并+贪心）

题目 n(n<2e5)个点的树&#xff0c;点i权值ai&#xff08;1<ai<2^30&#xff09; 修改最少的点的权值&#xff0c;使得树上不存在异或和为0的简单路径&#xff0c;输出最少的点数 权值可以被修改成任意正整数&#xff08;可以是无限大&#xff09; 思路来源 官方…
阅读更多...
【leetcode】环形链表✚环形链表II

【leetcode】环形链表✚环形链表II

大家好&#xff0c;我是苏貝&#xff0c;本篇博客带大家刷题&#xff0c;如果你觉得我写的还不错的话&#xff0c;可以给我一个赞&#x1f44d;吗&#xff0c;感谢❤️ 目录 1.环形链表解题拓展&#xff1a; 2.环形链表II 1.环形链表 点击查看题目 解题 思路: bool hasCycle…
阅读更多...
MySQL 多表查询 连接查询 内连接

MySQL 多表查询 连接查询 内连接

介绍 内连接查询是两张表中交集的部分 连接模式 隐式内连接 SELECT 字段列表 FROM 表1,表2 WHERE 条件显式内连接 SELECT 字段列表 FROM 表1 [INNER] JOIN 表2 ON 连接条件案例 有两张表一个表为学生表&#xff0c;另一个表为班级表&#xff0c;现在需要查询学生时候在查…
阅读更多...
接口测试（全）

接口测试（全）

&#x1f345; 视频学习&#xff1a;文末有免费的配套视频可观看 &#x1f345; 关注公众号【互联网杂货铺】&#xff0c;回复 1 &#xff0c;免费获取软件测试全套资料&#xff0c;资料在手&#xff0c;涨薪更快 大多数人对于接口测试都觉得是一种高大上的测试&#xff0c;觉得…
阅读更多...
羊大师分析，羊奶粉适合什么样的人群喝

羊大师分析，羊奶粉适合什么样的人群喝

羊大师分析&#xff0c;羊奶粉适合什么样的人群喝 羊奶粉适合多种人群食用&#xff0c;包括儿童、老年人、孕妇以及身体虚弱或处于疾病康复期的人群。 对于儿童来说&#xff0c;羊奶粉是一种很好的营养品。它含有丰富的蛋白质、脂肪、矿物质和维生素&#xff0c;能够满足儿童…
阅读更多...
【前端素材】推荐优质后台管理系统网页Star admin平台模板（附源码）

【前端素材】推荐优质后台管理系统网页Star admin平台模板（附源码）

一、需求分析 1、系统定义 后台管理系统是一种用于管理和控制网站、应用程序或系统的管理界面。它通常被设计用来让网站或应用程序的管理员或运营人员管理内容、用户、数据以及其他相关功能。后台管理系统是一种用于管理网站、应用程序或系统的工具&#xff0c;通常由管理员使…
阅读更多...
黑马JUC笔记

黑马JUC笔记

黑马JUC笔记 1.概览 2.进程与线程 2.1 进程与线程 进程 程序由指令和数据组成&#xff0c;但这些指令要运行&#xff0c;数据要读写&#xff0c;就必须将指令加载至 CPU&#xff0c;数据加载至内存。在 指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管…
阅读更多...
Cisco Secure ACS 5.8.0.32 安装 + Crack 教程

Cisco Secure ACS 5.8.0.32 安装 + Crack 教程

Cisco Secure ACS 5.8.0.32 安装 Crack 教程 前言系统环境开始安装 开始破解导入授权文件 前言 在ESXi 6.7 上经历过无数次的安装尝试 测试了各种兼容版本都没有安装成功,记最后一次安装成功的过程. 系统环境 服务器 : Dell R720xd CPU : E5-2620 v2 系统 : ESXi 6.7…
阅读更多...
简单控件属性设置

简单控件属性设置

1、设置文本的内容 <?xml version"1.0" encoding"utf-8"?> <LinearLayout xmlns:android"http://schemas.android.com/apk/res/android"android:layout_width"match_parent"android:layout_height"match_parent"…
阅读更多...
十四、Qt主机信息与网络编程

十四、Qt主机信息与网络编程

一、主机信息 1、主机信息接口 QHostInfo&#xff1a;获取主机名称和IP地址QNetWorkInterface&#xff1a;获取主机的所有网络接口&#xff0c;包括子网掩码和广播地址等 &#xff08;1&#xff09;使用 项目添加模块QT network2、实现程序 &#xff08;1&#xff0…
阅读更多...
【01】openEuler 源码安装 PostgreSQL

【01】openEuler 源码安装 PostgreSQL

openEuler 源码安装 PostgreSQL 部署环境说明Shell 前端软件包管理器基础概念YUM 简介DNF 简介 源码安装 PostgreSQL环境变量&#xff08;env&#xff09;设置临时环境变量设置永久环境变量设置 初始化数据库&#xff08;initdb&#xff09; 数据库基本操作数据库基本配置&…
阅读更多...
c++结构体内存对齐

c++结构体内存对齐

结构体内存对齐 试试运行下面的例子 #include <stdio.h> #include <stdlib.h>using namespace std;struct A{char c;int i; };struct B{char c; int i; double d; };struct C{char c;int i;double d;char c1; };int main(){printf("sizeof(A): %d\n"…
阅读更多...
SparkStreaming在实时处理的两个场景示例

SparkStreaming在实时处理的两个场景示例

简介 Spark Streaming是Apache Spark生态系统中的一个组件&#xff0c;用于实时流式数据处理。它提供了类似于Spark的API&#xff0c;使开发者可以使用相似的编程模型来处理实时数据流。 Spark Streaming的工作原理是将连续的数据流划分成小的批次&#xff0c;并将每个批次作…
阅读更多...
适配器模式 详解 设计模式

适配器模式 详解 设计模式

适配器模式 适配器模式是一种结构型设计模式&#xff0c;其主要作用是解决两个不兼容接口之间的兼容性问题。适配器模式通过引入一个适配器来将一个类的接口转换成客户端所期望的另一个接口&#xff0c;从而让原本由于接口不匹配而无法协同工作的类能够协同工作。 结构 适配…
阅读更多...
想要调用淘宝开放平台API，没有申请应用怎么办？

想要调用淘宝开放平台API，没有申请应用怎么办？

用淘宝自定义API接口可以访问淘宝开放平台API。 custom-自定义API操作 taobao.custom 公共参数 注册账号获取API请求地址 名称类型必须描述keyString是调用key&#xff08;必须以GET方式拼接在URL中&#xff09;secretString是调用密钥api_nameString是API接口名称&#xf…
阅读更多...
Docker与虚拟机比较

Docker与虚拟机比较

在对比Docker和虚拟机前&#xff0c;先简单了解下虚拟化&#xff0c;明确Docker和虚拟机分别对应的虚拟化级别&#xff0c;然后对Docker和虚拟机进行比较。需要注意的是&#xff0c;Docker和虚拟机并没有什么可比性&#xff0c;而是Docker使用的容器技术和虚拟机使用的虚拟化技…
阅读更多...
【K8S类型系统】一文梳理 K8S 各类型概念之间的关系（GVK/GVR/Object/Schema/RestMapper）

【K8S类型系统】一文梳理 K8S 各类型概念之间的关系（GVK/GVR/Object/Schema/RestMapper）

参考 k8s 官方文档 https://kubernetes.io/zh-cn/docs/reference/https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.29/ 重点 Kubernetes源码学习-kubernetes基础数据结构 - 知乎 重点 Kubernetes类型系统 | 李乾坤的博客 重点 k8s源码学习-三大核心数…
阅读更多...
前端学习第二天-html提升

前端学习第二天-html提升

达标要求 了解列表的分类 熟练掌握列表的用法 熟练掌握表格的结构构成 合并单元格 表单的组成 熟练掌握表单控件分类的使用 1.列表 1.1 无序列表 <ul>&#xff1a;定义无序列表&#xff0c;并且只能包含<li>子元素。 <li>&#xff1a;定义列表项&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023