操作系统原理笔记

前言
内容参考 小林coding图解系统

一.硬件结构

软中断

总结：
为了避免由于中断处理程序执行时间过长，而影响正常进程的调度，Linux 将中断处理程序分为上半部和下半部：

  • 上半部，对应硬中断，由硬件触发中断，用来快速处理中断；
  • 下半部，对应软中断，由内核触发中断，用来异步处理上半部未完成的工作；

Linux 中的软中断包括网络收发、定时、调度 RCU 锁等各种类型，可以通过查看 /proc/softirqs 来观察软中断的累计中断次数情况，
如果要实时查看中断次数的变化率，可以使用 watch -d cat /proc/softirqs 命令。

每一个 CPU 都有各自的软中断内核线程，我们还可以用 ps 命令来查看内核线程，一般名字在中括号里面到，都认为是内核线程。

如果在 top 命令发现，CPU 在软中断上的使用率比较高，而且 CPU 使用率最高的进程也是软中断 ksoftirqd 的时候，这种一般可以认为系统的开销被软中断占据了

这时我们就可以分析是哪种软中断类型导致的，一般来说都是因为网络接收软中断导致的，如果是的话，可以用 sar 命令查看是哪个网卡的有大量的网络包接收，再用 tcpdump 抓网络包，做进一步分析该网络包的源头是不是非法地址，如果是就需要考虑防火墙增加规则，如果不是，则考虑硬件升级等。

二.操作系统结构

三.内存管理

四.进程与线程

4.1 进程、线程基础知识

4.1.1 进程

进程图

  • NULL -> 创建状态：一个新进程被创建时的第一个状态；
  • 创建状态 -> 就绪状态：当进程被创建完成并初始化后，一切就绪准备运行时，变为就绪状态，这个过程是很快的;
  • 就绪态 -> 运行状态：处于就绪状态的进程被操作系统的进程调度器选中后，就分配给 CPU 正式运行该进程；
  • 运行状态 -> 结束状态：当进程已经运行完成或出错时，会被操作系统作结束状态处理；
  • 运行状态 -> 就绪状态：处于运行状态的进程在运行过程中，由于分配给它的运行时间片用完，操作系统会把该进程变为就绪态，接着从就绪态选中另外一个进程运行；
  • 运行状态 -> 阻塞状态：当进程请求某个事件且必须等待时，例如请求 I/O 事件；
  • 阻塞状态 -> 就绪状态：当进程要等待的事件完成时，它从阻塞状态变到就绪状态；
    • 阻塞挂起状态：进程在外存（硬盘）并等待某个事件的出现；
    • 就绪挂起状态：进程在外存（硬盘），但只要进入内存，即刻立刻运行；”
      • 进程挂起其他原因
        • 通过 sleep 让进程间歇性挂起，其工作原理是设置一个定时器，到期后唤醒进程。
        • 用户希望挂起一个程序的执行，比如在 Linux 中用 Ctrl+Z 挂起进程；

进程控制结构

在操作系统中，是用进程控制块（process control block，PCB）数据结构来描述进程的。

PCB是进程存在的唯一标识
包含了：

  • 进程描述信息
    • 进程标识符：标识各个进程，每个进程都有一个并且唯一的标识符；
    • 用户标识符：进程归属的用户，用户标识符主要为共享和保护服务；
  • 进程控制和管理信息
    • 进程当前状态，如 new、ready、running、waiting 或 blocked 等;
    • 进程优先级：进程抢占 CPU 时的优先级；
  • 资源分配清单
    • 有关内存地址空间或虚拟地址空间的信息，所打开文件的列表和所使用的 I/O 设备信息。
  • CPU相关信息
    • CPU 中各个寄存器的值，当进程被切换时，CPU 的状态信息都会被保存在相应的 PCB 中，以便进程重新执行时，能从断点处继续执行。

PCB 的组织形式：

  • 通常是通过链表的方式进行组织，把具有相同状态的进程链在一起，组成各种队列。
  • 还有索引的形式将同一状态的进程组织在一个索引表中，索引表项指向相应的 PCB，不同状态对应不同的索引表
  • 由于进程通常需要销毁、创建等操作，使用链表更加灵活

进程的控制

操作系统允许一个进程创建另一个进程，而且允许子进程继承父进程所拥有的资源，当子进程被终止时，其在父进程处继承的资源应当还给父进程。同时，终止父进程时同时也会终止其所有的子进程。

创建进程

  1. 为新进程分配一个唯一的进程标识号，并申请一个空白的 PCB，PCB 是有限的，若申请失败则创建失败；
  2. 为进程分配资源，此处如果资源不足，进程就会进入等待状态，以等待资源；
  3. 初始化 PCB；
  4. 如果进程的调度队列能够接纳新进程，那就将进程插入到就绪队列，等待被调度运行；

终止进程
可以有 3 种终止方式：正常结束、异常结束以及外界干预（信号 kill 掉）

  1. 查找需要终止的进程的 PCB；
  2. 如果处于执行状态，则立即终止该进程的执行，然后将 CPU 资源分配给其他进程；
  3. 如果其还有子进程，则应将其所有子进程终止；
  4. 将该进程所拥有的全部资源都归还给父进程或操作系统；
  5. 将其从 PCB 所在队列中删除；

值得注意的是，Linux 操作系统对于终止有子进程的父进程，会把子进程交给 1 号进程接管

阻塞进程
当进程需要等待某一事件完成时，它可以调用阻塞语句把自己阻塞等待。而一旦被阻塞等待，它只能由另一个进程唤醒。

  1. 找到将要被阻塞进程标识号对应的 PCB；
  2. 如果该进程为运行状态，则保护其现场，将其状态转为阻塞状态，停止运行；
  3. 将该 PCB 插入到阻塞队列中去；

唤醒进程
进程由「运行」转变为「阻塞」状态是由于进程必须等待某一事件的完成，所以处于阻塞状态的进程是绝对不可能叫醒自己的。
如果某进程正在等待 I/O 事件，需由别的进程发消息给它，则只有当该进程所期待的事件出现时，才由发现者进程用唤醒语句叫醒它。

  1. 在该事件的阻塞队列中找到相应进程的 PCB；
  2. 将其从阻塞队列中移出，并置其状态为就绪状态；
  3. 把该 PCB 插入到就绪队列中，等待调度程序调度；”

进程的上下文切换

一个进程切换到另一个进程运行，称为进程的上下文切换
在了解进程上下文切换前，不妨看一看什么是 CPU 上下文切换。

CPU 上下文 : CPU 寄存器和程序计数是 CPU 在运行任何任务前，所必须依赖的环境，这些环境就叫做 CPU 上下文

CPU 上下文切换

  • CPU 上下文切换就是先把前一个任务的 CPU 上下文（CPU 寄存器和程序计数器）保存起来，然后加载新任务的上下文到这些寄存器和程序计数器，最后再跳转到程序计数器所指的新位置，运行新任务。
  • CPU 上下文切换分成:
    • 进程上下文切换
    • 线程上下文切换
    • 中断上下文切换

另外，进程是由内核管理和调度的，所以进程的切换只能发生在内核态。 所以，进程的上下文切换不仅包含了虚拟内存、栈、全局变量等用户空间的资源，还包括了内核堆栈、寄存器等内核空间的资源。

课堂笔记

fork()

将进程一分为二

printf("ok");
fork();
printf("ok");

像这样的代码，会打印 3 次 ok ，产生的进程会获得一个 process identifier(pid).

for(int i = 0; i < 3; i++)
    fork();
printf("hello");

而像这样的代码将会执行 8 次 hello，进程树类似于二叉树

  • pid > 0, 是父进程, pid = 0, 是子进程
终止进程
  • exit()，呼叫操作系统终止进程
    • 若是子进程，数据返回给父进程（通过wait()）
    • 若是父进程，占用资源由将由操作系统重新分配
  • 父进程通过abort()终止子进程
    • 子进程占用资源过多
    • 子进程无需存在
    • 父进程即将终止，要先终止子进程

pid = wait(&status)，可以获取终止进程的 pid

  • 如果父亲在运行但是没有 waiting(执行wait())，这个子进程将被称为 zombie
  • 如果父进程没有waiting就被终止了，这个子进程就被称为 orphan
缓冲区

4.1.2 线程(Thread)

什么是线程？

  • 线程是进程当中的一条执行流程。

同一个进程内多个线程之间可以共享代码段、数据段、打开的文件等资源，但每个线程各自都有一套独立的寄存器和栈，这样可以确保线程的控制流是相对独立的。”

线程的优点

  • 一个进程中可以同时存在多个线程；
  • 各个线程之间可以并发执行；
  • 各个线程之间可以共享地址空间和文件等资源；

线程的缺点

  • 当进程中的一个线程崩溃时，会导致其所属进程的所有线程崩溃。

线程与进程的比较

比较如下：

  • 进程是资源（包括内存、打开的文件等）分配的单位，线程是 CPU 调度的单位；
  • 进程拥有一个完整的资源平台，而线程只独享必不可少的资源，如寄存器和栈；
  • 线程同样具有就绪、阻塞、执行三种基本状态，同样具有状态之间的转换关系；
  • 线程能减少并发执行的时间和空间开销；

线程减少开销体现在：

  • 线程的创建时间比进程快

    因为进程在创建的过程中，还需要资源管理信息，比如内存管理信息、文件管理信息，而线程在创建的过程中，不会涉及这些资源管理信息，而是共享它们;

  • 线程的终止时间比进程快，因为线程释放的资源相比进程少很多；

  • 同一个进程内的线程切换比进程切换快

    因为线程具有相同的地址空间（虚拟内存共享），这意味着同一个进程的线程都具有同一个页表，那么在切换的时候不需要切换页表。而对于进程之间的切换，切换的时候要把页表给切换掉，而页表的切换过程开销是比较大的；

  • 由于同一进程的各线程间共享内存和文件资源，那么在线程之间数据传递的时候，就不需要经过内核了，这就使得线程之间的数据交互效率更高了；

线程上下文切换

从上一小节可知, 线程与进程最大的区别在于：线程是调度的基本单位，而进程则是资源拥有的基本单位。

一种方式去理解进程和线程：

  • 当进程只有一个线程，两者可以认为等价
  • 当进程拥有多个线程，这些线程会共享相同的虚拟内存和全局变量等资源，这些资源在上下文切换时是不需要修改的。

线程上下文切换

  • 当两个线程不是属于同一个进程，则切换的过程就跟进程上下文切换一样；

  • 当两个线程是属于同一个进程，因为虚拟内存是共享的，所以在切换时，虚拟内存这些资源就保持不动，只需要切换线程的私有数据、寄存器等不共享的数据；

线程实现

三种实现方式：

  • 用户线程（User Thread）：在用户空间实现的线程，不是由内核管理的线程，是由用户态的线程库来完成线程的管理；
  • 内核线程（Kernel Thread）：在内核中实现的线程，是由内核管理的线程；
  • 轻量级进程（LightWeight Process）：在内核中来支持用户线程
用户线程

用户线程和内核线程可以具有一对多、一对一、多对多的关系模式

用户线程是基于用户态的线程管理库来实现的，那么线程控制块（Thread Control Block, TCB） 也是在库里面来实现的，对于操作系统而言是看不到这个 TCB 的，它只能看到整个进程的 PCB。”

用户线程的整个线程管理和调度，操作系统是不直接参与的，而是由用户级线程库函数来完成线程的管理，包括线程的创建、终止、同步和调度等。

用户线程的优点

  • 每个进程都需要有它私有的线程控制块（TCB）列表，用来跟踪记录它各个线程状态信息（PC、栈指针、寄存器），TCB 由用户级线程库函数来维护，可用于不支持线程技术的操作系统；
  • 用户线程的切换也是由线程库函数来完成的，无需用户态与内核态的切换，所以速度特别快；

用户线程的缺点

  • 由于操作系统不参与线程的调度，如果一个线程发起了系统调用而阻塞，那进程所包含的用户线程都不能执行了。
  • 当一个线程开始运行后，除非它主动地交出 CPU 的使用权，否则它所在的进程当中的其他线程无法运行，因为用户态的线程没法打断当前运行中的线程，它没有这个特权，只有操作系统才有，但是用户线程不是由操作系统管理的。
  • 由于时间片分配给进程，故与其他进程比，在多线程执行时，每个线程得到的时间片较少，执行会比较慢；
内核线程

内核线程是由操作系统管理的，线程对应的 TCB 自然是放在操作系统里的，这样线程的创建、终止和管理都是由操作系统负责。

内核线程的优点

  • 在一个进程当中，如果某个内核线程发起系统调用而被阻塞，并不会影响其他内核线程的运行；
  • 分配给线程，多线程的进程获得更多的 CPU 运行时间；

内核线程的缺点：

  • 在支持内核线程的操作系统中，由内核来维护进程和线程的上下文信息，如 PCB 和 TCB；
  • 线程的创建、终止和切换都是通过系统调用的方式来进行，因此对于系统来说，系统开销比较大；
轻量级线程

轻量级进程（Light-weight process，LWP）是内核支持的用户线程，一个进程可有一个或多个 LWP，每个 LWP 是跟内核线程一对一映射的，也就是 LWP 都是由一个内核线程支持

在大多数系统中，LWP与普通进程的区别也在于它只有一个最小的执行上下文和调度程序所需的统计信息, 不需要过多的额外信息

1 : 1 模式

一个线程对应到一个 LWP 再对应到一个内核线程，如上图的进程 4，属于此模型。

  • 优点：实现并行，当一个 LWP 阻塞，不会影响其他 LWP；
  • 缺点：每一个用户线程，就产生一个内核线程，创建线程的开销较大。

N : 1 模式

多个用户线程对应一个 LWP 再对应一个内核线程，线程管理是在用户空间完成的，此模式中用户的线程对操作系统不可见。

  • 优点：用户线程要开几个都没问题，且上下文切换发生用户空间，切换的效率较高；
  • 缺点：一个用户线程如果阻塞了，则整个进程都将会阻塞，另外在多核 CPU 中，是没办法充分利用 CPU 的。

M : N 模式
根据前面的两个模型混搭一起，就形成 M:N 模型，该模型提供了两级控制，首先多个用户线程对应到多个 LWP，LWP 再一一对应到内核线程

  • 优点：综合了前两种优点，大部分的线程上下文发生在用户空间，且多个线程又可以充分利用多核 CPU 的资源。

组合模式

此进程结合 1:1 模型和 M:N 模型。开发人员可以针对不同的应用特点调节内核线程的数目来达到物理并行性和逻辑并行性的最

4.1.3 调度

选择一个进程运行这一功能是在操作系统中完成的，通常称为 调度程序（scheduler）

调度时机

在进程的生命周期中，当进程从一个运行状态到另外一状态变化的时候，其实会触发一次调度。
从就绪态 -> 运行态：当进程被创建时，会进入到就绪队列，操作系统会从就绪队列选择一个进程运行；
从运行态 -> 阻塞态：当进程发生 I/O 事件而阻塞时，操作系统必须另外一个进程运行；
从运行态 -> 结束态：当进程退出结束后，操作系统得从就绪队列选择另外一个进程运行；

把调度算法分为两类

  • 非抢占式调度算法挑选一个进程，然后让该进程运行直到被阻塞，或者直到该进程退出，才会调用另外一个进程，也就是说不会理时钟中断这个事情。

  • 抢占式调度算法挑选一个进程，然后让该进程只运行某段时间，如果在该时段结束时，该进程仍然在运行时，则会把它挂起，接着调度程序从就绪队列挑选另外一个进程。这种抢占式调度处理，
    需要在时间间隔的末端发生时钟中断，以便把 CPU 控制返回给调度程序进行调度，也就是常说的 时间片机制。”

调度原则

  • 原则一：如果运行的程序，发生了 I/O 事件的请求，那 CPU 使用率必然会很低，因为此时进程在阻塞等待硬盘的数据返回。这样的过程，势必会造成 CPU 突然的空闲。所以，为了提高 CPU 利用率，在这种发送 I/O 事件致使 CPU 空闲的情况下，调度程序需要从就绪队列中选择一个进程来运行。
  • 原则二：有的程序执行某个任务花费的时间会比较长，如果这个程序一直占用着 CPU，会造成系统吞吐量（CPU 在单位时间内完成的进程数量）的降低。所以，要提高系统的吞吐率，调度程序要权衡长任务和短任务进程的运行完成数量。
  • 原则三：从进程开始到结束的过程中，实际上是包含两个时间，分别是进程运行时间和进程等待时间，这两个时间总和就称为周转时间。进程的周转时间越小越好，如果进程的等待时间很长而运行时间很短，那周转时间就很长，这不是我们所期望的，调度程序应该避免这种情况发生。
  • 原则四：处于就绪队列的进程，也不能等太久，当然希望这个等待的时间越短越好，这样可以使得进程更快的在 CPU 中执行。所以，就绪队列中进程的等待时间也是调度程序所需要考虑的原则。
  • 原则五：对于鼠标、键盘这种交互式比较强的应用，我们当然希望它的响应时间越快越好，否则就会影响用户体验了。所以，对于交互式比较强的应用，响应时间也是调度程序需要考虑的原则。

总结

  • CPU 利用率：调度程序应确保 CPU 是始终匆忙的状态，这可提高 CPU 的利用率；
  • 系统吞吐量：吞吐量表示的是单位时间内 CPU 完成进程的数量，长作业的进程会占用较长的 CPU 资源，因此会降低吞吐量，相反，短作业的进程会提升系统吞吐量；
  • 周转时间：周转时间是进程运行和阻塞时间总和，一个进程的周转时间越小越好；
  • 等待时间：这个等待时间不是阻塞状态的时间，而是进程处于就绪队列的时间，等待的时间越长，用户越不满意；
  • 响应时间：用户提交请求到系统第一次产生响应所花费的时间，在交互式系统中，响应时间是衡量调度算法好坏的主要标准。”

调度算法

1. 先来先服务 FCFS \((First\;Come\;First\;Served)\)

先来后到，每次从就绪队列选择最先进入队列的进程，然后一直运行，直到进程退出或被阻塞，才会继续从队列中选择第一个进程接着运行。

  • 对长作业有利，适用于 CPU 繁忙型作业的系统，而不适用于 I/O 繁忙型作业的系统

2. 最短作业优先 SJF \((Shortest\;Job\;First)\)

它会优先选择运行时间最短的进程来运行，这有助于提高系统的吞吐量

  • 对长作业不利，如果有很多短作业在队列中，长作业执行时间不断推迟

3. 高响应比优先 HRRN \((Highest\;Response\;Ratio\;Next)\)

权衡了短作业和长作业。每次进行进程调度时，先计算「响应比优先级」，然后把「响应比优先级」最高的进程投入运行，「响应比优先级」的计算公式：

\[优先权 = \frac{等待时间+要求服务时间}{要求服务时间} \]

4. 时间片轮转 RR \((Round\;Robin)\)

最古老、最简单、最公平且使用最广的算法

每个进程被分配一个时间段，称为 时间片(Quantum)，即允许该进程在该时间段中运行。

  • 如果时间片用完，进程还在运行，那么将会把此进程从 CPU 释放出来，并把 CPU 分配给另外一个进程；
  • 如果该进程在时间片结束前阻塞或结束，则 CPU 立即进行切换；

时间片的关键点

  • 如果时间片设得太短会导致过多的进程上下文切换，降低了 CPU 效率；
  • 如果设得太长又可能引起对短作业进程的响应时间变长。一般来说，时间片设为 20ms~50ms 通常是一个比较合理的折中值。

5. 最高优先级 HPF\((Highest\;Priority\;First)\)

希望调度是有优先级的，即希望调度程序能从就绪队列中选择最高优先级的进程进行运行
进程的优先级可以分为，静态优先级和动态优先级;

  • 静态优先级：创建进程时候，就已经确定了优先级了，然后整个运行时间优先级都不会变化
  • 动态优先级：根据进程的动态变化调整优先级，比如如果进程运行时间增加，则降低其优先级，如果进程等待时间（就绪队列的等待时间）增加，则升高其优先级，也就是随着时间的推移增加等待进程的优先级。

两种处理优先级高的方法，非抢占式和抢占式：

  • 非抢占式：当就绪队列中出现优先级高的进程，运行完当前进程，再选择优先级高的进程。
  • 抢占式：当就绪队列中出现优先级高的进程，当前进程挂起，调度优先级高的进程运行。

6. 多级反馈队列 MFQ\((Multilevel Feedback Queue)\)

是「时间片轮转算法」和「最高优先级算法」的综合和发展。

  • 「多级」表示有多个队列，每个队列优先级从高到低，同时优先级越高时间片越短。
  • 「反馈」表示如果有新的进程加入优先级高的队列时，立刻停止当前正在运行的进程，转而去运行优先级高的队列；

算法调度工作实现：

  • 设置了多个队列，赋予每个队列不同的优先级，每个队列优先级从高到低，同时优先级越高时间片越短；
  • 新的进程会被放入到第一级队列的末尾，按先来先服务的原则排队等待被调度，如果在第一级队列规定的时间片没运行完成，则将其转入到第二级队列的末尾，以此类推，直至完成；
  • 当较高优先级的队列为空，才调度较低优先级的队列中的进程运行。如果进程运行时，有新进程进入较高优先级的队列，则停止当前运行的进程并将其移入到原队列末尾，接着让较高优先级的进程运行

对于短作业可能可以在第一级队列很快被处理完。对于长作业，如果在第一级队列处理不完，可以移入下次队列等待被执行，虽然等待的时间变长了，但是运行时间也变更长了，所以该算法很好的兼顾了长短作业，同时有较好的响应时间。”

4.2 进程间通信

4.2.1 管道

管道实质是内核里的一段缓存
a | b，将 a 的输出作为 b 的输入。使用命名管道 mkfifo myPipe, myPipe 是管道的名字。管道以文件形式存在，类型为 p。
匿名管道的创建，需要通过下面这个系统调用：

int pipe(int fd[2])

这里表示创建一个匿名管道，并返回了两个描述符，一个是管道的读取端描述符 fd[0]，另一个是管道的写入端描述符 fd[1]。注意，这个匿名管道是特殊的文件，只存在于内存，不存于文件系统中。
使用 fork 创建子进程，创建的子进程会复制父进程的文件描述符，这样就做到了两个进程各有两个「 fd[0] 与 fd[1]」，两个进程就可以通过各自的 fd 写入和读取同一个管道文件实现跨进程通信了。”
避免混乱通常做法：

  • 父进程关闭读取的 fd[0]，只保留写入的 fd[1]；
  • 子进程关闭写入的 fd[1]，只保留读取的 fd[0];

匿名管道: 它的通信范围是存在父子关系的进程
命名管道: 它可以在不相关的进程间也能相互通信

4.2.2 消息队列

管道的通信效率低，不适合进程间频繁交换数据，消息队列的通信模式就可以解决

消息队列是保存在内核中的消息链表”
在发送数据时，会分成一个一个独立的数据单元，也就是消息体（数据块），
消息体是用户自定义的数据类型，消息的发送方和接收方要约定好消息体的数据类型，
所以每个消息体都是固定大小的存储块，不像管道是无格式的字节流数据。

不足：

  • 通信不及时
  • 消息队列不适合比较大数据的传输, 在 Linux 中，MSGMAX 和 MSGMNB 以字节为单位，分别定义消息的最大长度和队列的最大长度。
  • 消息队列通信过程中，存在用户态与内核态之间的数据拷贝开销
    因为进程写入数据到内核中的消息队列时，会发生从用户态拷贝数据到内核态的过程，同理另一进程读取内核中的消息数据时，会发生从内核态拷贝数据到用户态的过程。

4.2.3 共享内存

共享内存采用虚拟内存技术，很好解决了消息队列，用户态与内核台的数据拷贝开销

共享内存的机制，就是拿出一块虚拟地址空间来，映射到相同的物理内存中

4.2.4 信号量

为了防止多进程竞争共享资源，而造成的数据错乱，所以需要保护机制，使得共享的资源，在任意时刻只能被一个进程访问。正好，信号量就实现了这一保护机制。

信号量是一个整型的计数器，主要用于实现进程间的互斥与同步，而不是用于缓存进程间通信的数据。
一个进程有一个信号量？maybe

控制信号量的两种原子操作：

  • 一个是 \(P\) 操作，这个操作会把信号量减去 \(1\)，相减后如果信号量 \(< 0\)，则表明资源已被占用，进程需阻塞等待；相减后如果信号量 \(>= 0\)，则表明还有资源可使用，进程可正常继续执行。
  • 另一个是 \(V\) 操作，这个操作会把信号量加上 \(1\)，相加后如果信号量 \(< 0\)，则表明当前有阻塞中的进程，于是会将该进程唤醒运行；相加后如果信号量 \(> 0\)，则表明当前没有阻塞中的进程；
    信号量的性质:
  • 其中，\(P\) 操作是用在进入共享资源之前，\(V\) 操作是用在离开共享资源之后，这两个操作是必须成对出现的
  • 信号量初始化为 \(1\)，代表互斥信号量。
  • 信号量初始化为 \(0\)，代表同步信号量。

4.2.5 信号

对于异常情况下的工作模式，就需要用「信号」的方式来通知进程。

信号事件的来源主要有硬件来源（如键盘 Cltr+C ）和软件来源（如 kill 命令）。

信号是进程间通信机制中唯一的异步通信机制，因为可以在任何时候发送信号给某一进程。
用户对进程的处理方式：

  1. 执行默认操作。Linux 对每种信号都规定了默认操作，例如, SIGTERM 信号，就是终止进程的意思。
  2. 捕捉信号。我们可以为信号定义一个信号处理函数。当信号发生时，我们就执行相应的信号处理函数。
  3. 忽略信号。当我们不希望处理某些信号的时候，就可以忽略该信号，不做任何处理。有两个信号是应用进程无法捕捉和忽略的，即 SIGKILL 和 SEGSTOP，它们用于在任何时候中断或结束某一进程。
posted @ 2022-03-07 13:32  Roshin  阅读(335)  评论(0)  编辑  收藏  举报
-->