操作系统进程线程相关知识点总结

操作系统重要知识点

实话说，写操作系统相关博客我是很没有头绪的，思路列了又删，复述书上的内容感觉不到任何好处；还是作罢；

搞起知识点记载，总算是与面试八股相关了；

一.进程和线程相关问题

说到操作系统，必须要了解的就是进程和线程，就像是最小构成一般，非常多的进程和线程才让操作系统这个庞然大物运转起来；

接下来会记录几个必会的问题；

进程和线程以及他们的区别

1. 定义：
   • 进程：一个独立的执行单位，拥有自己的内存空间、文件描述符、代码和数据段等资源。
   • 线程：一个进程中的一个执行流，与同一进程中的其他线程共享相同的内存空间和资源。
2. 资源开销：
   • 进程：相对较高的资源开销，包括内存空间、文件描述符、系统调用等。
   • 线程：较低的资源开销，因为线程共享进程的资源，如内存空间和文件描述符等。
3. 通信和同步：
   • 进程：进程间通信较为复杂，通常使用进程间通信（IPC）机制，如管道、消息队列、共享内存等。
   • 线程：线程间通信更加简单直接，因为它们共享同一地址空间，可以通过共享变量直接进行通信。但需要注意线程间的同步问题，避免出现竞态条件和数据不一致等情况。
4. 并发性：
   • 进程：进程之间相互独立，拥有各自的地址空间，因此进程的并发性相对较低。
   • 线程：线程共享进程的地址空间，因此可以更容易地实现并发执行，多个线程可以同时执行不同的任务，提高了程序的效率和响应速度。
5. 切换开销：
   • 进程：由于进程拥有独立的地址空间，进程切换的开销较大，需要保存和恢复大量的进程上下文。
   • 线程：线程共享进程的地址空间，线程切换的开销较小，通常只需要保存和恢复少量的线程上下文。

即

• 进程是具有一定功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源调度和分配的一个独立单位。
• 线程是进程的实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。
• 一个进程可以有多个线程，多个线程也可以并发执行

详细的来说：

进程的概念起源于操作系统的设计，它允许多个程序同时在计算机系统中运行，每个程序都被视为一个独立的进程。操作系统通过进程调度算法来决定哪些进程应该在何时执行，从而实现了系统资源的合理分配和利用。进程间可以通过进程间通信（IPC）机制进行数据交换和协作，从而完成复杂的任务和应用场景。

线程（Thread）是进程内的一个执行单元，是操作系统调度的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源，包括内存空间、文件描述符、打开的文件等。每个线程拥有独立的执行流程，可以独立执行任务，但它们共享同一进程的地址空间和资源。

与进程相比，线程的创建、销毁和切换开销更小，因为它们共享进程的资源。多线程编程可以提高程序的并发性和效率，在多核处理器上能够更好地利用硬件资源。线程间的通信更加简单直接，因为它们可以直接共享内存空间，可以通过共享变量等方式进行通信和同步。

总的来说，线程是进程内的执行流程，是操作系统调度的基本单位，它们共享进程的资源，可以独立执行任务。多线程编程可以提高程序的并发性和效率，但也需要注意线程安全性和资源竞争等问题，以确保程序的正确性和稳定性。

名词：

线程安全性：

线程安全性指的是在多线程编程中，当多个线程同时访问共享资源时，程序仍然能够正确地执行，并且不会产生不确定的结果或者破坏数据的一致性。换句话说，线程安全性保证了程序在并发执行时的正确性和稳定性。

在多线程环境中，如果多个线程同时访问共享资源，而没有进行适当的同步措施，就可能会出现竞态条件（Race Condition）和数据竞争（Data Race）等问题。这些问题可能导致数据的不一致性、程序的崩溃或者死锁等情况，从而影响程序的正确性和可靠性。

为了确保线程安全性，需要采取适当的同步机制和线程安全的编程技术，例如互斥锁（Mutex）、信号量（Semaphore）、读写锁（ReadWrite Lock）等。这些同步机制可以确保在同一时间只有一个线程能够访问共享资源，从而避免竞态条件和数据竞争等问题。

资源竞争：

资源竞争（Resource contention）指的是在多线程或多进程环境中，多个线程或进程同时竞争共享资源而导致的问题。这种竞争可能会导致数据的不一致性、程序的异常行为或性能下降等情况。

资源竞争通常发生在多个线程或进程试图同时访问共享资源时，这些资源可以是内存中的变量、文件、网络连接、设备等。当多个线程或进程同时修改同一个共享资源时，就可能出现竞态条件（Race Condition）或数据竞争（Data Race）等问题。

竞态条件是指程序的执行结果依赖于不同线程或进程执行操作的具体顺序，如果操作的执行顺序不同，可能会导致不同的结果。数据竞争则是指多个线程或进程同时访问共享数据，并且其中至少有一个线程进行写操作，而没有进行适当的同步，从而导致数据的不一致性或未定义的行为。

避免方法同上；

还是还是理解不了，呢推荐去看一下：

进程与线程的一个简单解释 - 阮一峰的网络日志 (ruanyifeng.com)

再回来看文字，应该就一目了然了；

线程同步是什么，方式有什么？

线程同步是指在多线程编程中，通过各种技术手段确保多个线程之间的协作和数据一致性。

1. 互斥锁（Mutex）：互斥锁是最常见的线程同步机制之一。它可以确保在同一时间只有一个线程能够访问共享资源，其他线程需要等待锁释放后才能继续执行。
2. 信号量（Semaphore）：信号量是一种更为通用的同步机制，可以用来控制多个线程对共享资源的访问。它可以允许多个线程同时访问共享资源，但通过设置信号量的初始值和调用 wait() 和 signal() 操作来控制并发访问的数量。
3. 条件变量（Condition Variable）：条件变量是一种用于线程间通信的同步机制，它可以让线程在特定条件下等待或者被唤醒。通常和互斥锁结合使用，用于实现复杂的线程同步模式，如生产者-消费者模型等。
4. 读写锁（ReadWrite Lock）：读写锁允许多个线程同时读取共享资源，但只允许一个线程进行写操作。这种锁适用于读操作远远多于写操作的场景，可以提高并发性能。
5. 屏障（Barrier）：屏障用于让多个线程在某个点上同步，等待所有线程到达后再一起继续执行。常用于分阶段任务的并行执行中。
6. 原子操作（Atomic Operation）：原子操作是不可中断的操作，可以保证在多线程环境中执行的完整性，如原子加减、原子比较交换等。
7. 消息队列（Message Queue）：消息队列是一种线程间通信的机制，可以让不同线程通过发送和接收消息来实现同步和数据交换。

同样，也会有进程同步

进程通信是什么，进程通信的方式

进程间通信（Inter-Process Communication，IPC）是指不同进程之间进行数据交换和共享信息的方式。在操作系统中，进程间通信是必不可少的，因为不同进程可能需要共享资源、协调工作或者传递数据。

1. 信号量（Semaphore）：信号量是一种用于进程间通信和同步的计数器。通过 wait() 和 signal() 操作，可以控制多个进程对共享资源的访问。信号量可以用于实现临界区保护、互斥访问、同步等功能。
2. 管道（Pipe）：管道是一种特殊的文件，可以实现单向的进程间通信。通过管道，一个进程可以将数据写入管道，另一个进程则可以从管道中读取数据，从而实现进程间的数据传输和同步。
3. 共享内存（Shared Memory）：共享内存是一种进程间通信的机制，允许多个进程共享同一块内存空间。通过共享内存，多个进程可以直接访问相同的内存地址，从而实现数据共享和同步。
4. 消息队列（Message Queue）：消息队列是一种进程间通信的机制，允许多个进程通过发送和接收消息来实现数据传输和同步。不同进程之间通过消息队列进行通信，可以实现进程间的解耦和异步通信。
5. 信号（Signal）：信号是一种进程间通信的机制，用于向进程发送异步通知。通过信号，一个进程可以向另一个进程发送特定的信号，从而触发相应的处理逻辑。
6. 套接字（Socket）：套接字是一种在网络上进行进程通信的方式，它允许不同主机上的进程之间进行数据交换。套接字可以在本地主机上的不同进程之间进行通信，也可以在网络上的不同主机之间进行通信。

名词：

设计模式

设计模式是在软件工程中常用的一种解决常见问题的模式化解决方案，它们提供了经过验证和可重用的设计思路。

1. 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。
2. 工厂模式（Factory Pattern）：定义一个创建对象的接口，但让子类决定实例化哪个类，使得一个类的实例化延迟到其子类。
3. 抽象工厂模式（Abstract Factory Pattern）：提供一个接口用于创建一系列相关或相互依赖的对象，而无需指定它们的具体类。
4. 建造者模式（Builder Pattern）：将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
5. 原型模式（Prototype Pattern）：通过复制现有对象来创建新对象，而不是通过实例化。
6. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。
7. 装饰者模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，而不需要子类化扩展。
8. 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。
9. 观察者模式（Observer Pattern）：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
10. 策略模式（Strategy Pattern）：定义一系列算法，将每个算法封装起来，并且使它们可以相互替换。
11. 模板方法模式（Template Method Pattern）：定义一个操作中的算法的骨架，将一些步骤延迟到子类中。
12. 状态模式（State Pattern）：允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。
13. 命令模式（Command Pattern）：将请求封装成对象，从而允许用不同的请求来参数化客户对象，队列或记录请求，并支持可撤销的操作。
14. 责任链模式（Chain of Responsibility Pattern）：为解除发送者和接收者之间的耦合，将多个对象连成一条链，并沿着这条链传递请求直到有一个对象处理它为止。
15. 迭代器模式（Iterator Pattern）：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

其实必考的就单例模式，工厂模式也较为重要

单例模式

单例模式是一种创建型设计模式，其目的是确保一个类只有一个实例，并提供一个全局访问点来访问该实例。单例模式在需要确保只有一个对象实例的情况下非常有用，比如数据库连接池、线程池、日志记录器等。

以下是单例模式的详细说明：

1. 私有构造函数（Private Constructor）：为了防止外部类直接实例化单例类，通常将单例类的构造函数设为私有，这样外部类就无法通过 new 关键字来创建该类的实例。
2. 静态成员变量（Static Member Variable）：单例类通常会包含一个静态成员变量，用于存储该类的唯一实例。这个静态成员变量通常会被设为私有，并且被声明为该类的类型。
3. 静态方法（Static Method）：为了让外部类能够访问到单例类的实例，单例类通常会提供一个静态方法来获取该实例。这个静态方法通常被称为 getInstance() 方法，它负责检查是否已经存在该实例，如果不存在则创建一个新的实例，并返回该实例。
4. 懒汉式 vs 饿汉式：单例模式可以根据实例化的时机分为懒汉式和饿汉式两种。懒汉式在第一次调用 getInstance() 方法时才会创建实例，而饿汉式在类加载的时候就会创建实例。懒汉式的优点是延迟实例化，节省资源，但可能存在多线程安全问题；而饿汉式在类加载时就创建实例，避免了多线程安全问题，但可能会造成资源浪费。
5. 线程安全性（Thread Safety）：在多线程环境下使用单例模式时，需要确保单例类的 getInstance() 方法是线程安全的。可以通过加锁（如 synchronized 关键字）来实现线程安全，也可以采用双重检查锁定（Double-Checked Locking）等技术来提高性能。
6. 序列化与反序列化（Serialization and Deserialization）：当单例类需要实现序列化和反序列化时，需要注意确保反序列化过程中不会破坏单例模式，可以通过重写 readResolve() 方法来实现。

工厂模式

工厂模式是一种创建型设计模式，其目的是定义一个用于创建对象的接口，但让子类决定实例化哪个类。工厂模式将对象的实例化过程延迟到其子类，从而使得一个类的实例化与其子类解耦，提高了代码的灵活性和可维护性。

工厂模式通常包含以下几个要素：

1. 抽象产品接口（Abstract Product Interface）：定义了所创建对象的接口，通常是一个抽象类或接口，包含了对象的通用方法。
2. 具体产品类（Concrete Product Classes）：实现了抽象产品接口，是工厂模式所创建对象的具体类型。
3. 抽象工厂接口（Abstract Factory Interface）：定义了用于创建对象的方法，通常是一个接口，包含了创建对象的抽象方法。
4. 具体工厂类（Concrete Factory Classes）：实现了抽象工厂接口，负责创建具体产品类的实例。具体工厂类通常包含一个或多个工厂方法，用于创建具体产品的实例。

工厂模式可以分为三种常见的形式：

1. 简单工厂模式（Simple Factory Pattern）：在简单工厂模式中，工厂类负责根据客户端的请求创建对象。客户端通过工厂类的静态方法来获取所需对象的实例。简单工厂模式将对象的实例化过程封装在工厂类中，客户端无需关心对象的创建过程。
2. 工厂方法模式（Factory Method Pattern）：在工厂方法模式中，每个具体工厂类对应一个具体产品类，每个具体工厂类负责创建对应的具体产品类的实例。工厂方法模式将对象的实例化过程交给了子类来实现，从而使得类的实例化延迟到了子类。
3. 抽象工厂模式（Abstract Factory Pattern）：在抽象工厂模式中，工厂类负责创建一系列相关或相互依赖的对象，而无需指定它们的具体类。抽象工厂模式提供了一种创建一系列相关对象的统一接口，使得客户端可以在不关心具体实现的情况下创建对象。

工厂模式适用于需要在运行时选择创建哪个具体类的情况，或者需要根据条件来选择不同的类。它提供了一种灵活的方式来创建对象，避免了直接实例化具体类带来的耦合性，同时也提高了代码的可扩展性和可维护性。

更详细点的以及其他模式会在其他文章中说明。

既然说了进程和线程，再提一嘴go中的协程

协程

在 Go 语言中，协程（Goroutine）是一种轻量级的线程（Thread）实现，它由 Go 运行时环境管理。协程是一种用户态线程，由 Go 语言的运行时环境调度和管理，而不是由操作系统内核调度。因此，与传统的线程相比，协程的创建、销毁和切换开销更小，可以高效地支持大量的并发执行。

协程与传统的操作系统线程（Thread）相比有几个显著的优势：

1. 轻量级：协程是轻量级的执行单元，其创建、销毁和切换开销远远小于操作系统线程。因此，可以创建大量的协程而不会导致系统资源的浪费。
2. 用户态调度：协程的调度和管理是在用户态完成的，不依赖于操作系统内核的调度。这意味着可以更加灵活地控制协程的调度和执行，避免了内核态和用户态之间的频繁切换，提高了性能。
3. 更高的并发性：由于协程的轻量级特性，可以创建大量的协程来处理并发任务，而不会消耗太多的系统资源。这使得协程在需要高并发性能的场景下表现出色。
4. 更好的抽象：协程提供了更高级别的抽象，使得并发编程更加简单直观。在 Go 语言中，使用协程可以像普通函数调用一样简单，而不需要关注底层的线程管理细节。

虽然协程实际上是在操作系统线程上执行的，但由于其轻量级和灵活性，使得协程在处理并发任务时比传统的线程更具优势。因此，许多现代编程语言和框架都提供了对协程的支持，以简化并发编程并提高性能。

进程有哪几种状态

1. 就绪态（Ready）：进程已经准备好开始执行，但还未被分配到 CPU 时间片。通常是因为进程正在等待系统资源或者等待调度。
2. 运行态（Running）：进程正在执行，正在使用 CPU 时间片执行其任务。在单核处理器上，同一时刻只能有一个进程处于运行态。
3. 阻塞态（Blocked）：进程暂时无法继续执行，因为它正在等待某些事件的发生，比如等待文件读写完成、等待用户输入等。当事件发生时，进程可以从阻塞态转换为就绪态。
4. 创建态（Created）：进程已经被创建，但还未被加载到内存中开始执行。
5. 终止态（Terminated）：进程已经执行结束，不再占用系统资源。这可能是正常结束，也可能是由于异常情况导致的提前结束。

而我们平常讨论的三种基本状态：就绪状态，运行状态，阻塞状态

一个进程在运行期间，不断地从一种状态转换到另一种状态，它可以多次处于就绪状态和执行状态，也可以多次处于阻塞状态。

(1) 就绪→执行
处于就绪状态的进程，当进程调度程序为之分配了处理机后，该进程便由就绪状态转变成执行状态。

例： 当前运行进程阻塞，调度程序选一个优先权最高的进程占有处理机；

(2) 执行→就绪
处于执行状态的进程在其执行过程中，因分配给它的一个时间片已用完而不得不让出处理机，于是进程从执行状态转变成就绪状态。

例： 当前运行进程时间片用完；

(3) 执行→阻塞
正在执行的进程因等待某种事件发生而无法继续执行时，便从执行状态变成阻塞状态。

例：当前运行进程等待键盘输入，进入了睡眠状态。

(4) 阻塞→就绪
处于阻塞状态的进程，若其等待的事件已经发生，于是进程由阻塞状态转变为就绪状态。

例：I/O操作完成，被中断处理程序唤醒。

操作系统中进程调度策略有哪几种

先来先服务

先来先服务（First Come, First Served，FCFS）调度算法是最简单的进程调度算法之一，其原则是按照进程到达的先后顺序进行调度。当一个进程到达时，它就被放入就绪队列的末尾，等待CPU执行。一旦CPU空闲，操作系统就会选择队列中的第一个进程进行执行。

短作业优先调度算法

短作业优先（Shortest Job First，SJF）调度算法是一种按照预计执行时间最短的顺序来调度进程的算法。它的核心思想是优先选择执行时间最短的进程，以最小化平均等待时间，并提高系统的吞吐量。

高优先权优先调度算法

高优先权优先调度算法是一种按照进程优先级来选择下一个要执行的进程的算法。此算法常被用于批处理系统中，作为作业调度算法，也作为多种操作系统中的进程调度算法，还可用于实时系统中。当把该算法用于作业调度时，系统将从后备队列中选择若干个优先权最高的作业装入内存。当用于进程调度时，该算法是把处理机分配给就绪队列中优先权最高的进程，这时，又可进一步把该算法分成如下两种。

高响应比优先调度算法

高响应比优先调度算法是一种用于操作系统中的进程调度算法，旨在提高系统对用户请求的响应速度。该算法根据进程的等待时间和服务时间来计算响应比，然后选择具有最高响应比的进程优先执行，以确保长时间等待的进程能够及时得到服务。

时间片轮转法

时间片轮转法（Round Robin Scheduling）是一种常见的调度算法，通常用于操作系统中对进程进行调度。它的基本原理是每个进程被分配一个小的时间片（如10毫秒），在该时间片内执行，然后被挂起，等待下一个时间片执行。如果进程在时间片用完之前没有完成，它将被暂停，并放到就绪队列的末尾，等待下一次调度。

多级反馈队列调度算法

多级反馈队列调度算法（Multilevel Feedback Queue Scheduling）是一种综合了多种调度策略的进程调度算法。它将就绪队列划分为多个队列，每个队列具有不同的优先级，通常是由高到低，每个队列都采用先来先服务（FCFS）的调度策略。

在多级反馈队列调度算法中，进程首先进入最高优先级的队列，如果一个进程的时间片用完了但仍然没有完成，它将被移到下一个较低优先级的队列中等待执行。如果进程在一个较低优先级队列中等待的时间太久，系统可能会将其提升到一个较高优先级的队列，以提高其执行的机会。

这种调度算法的优点是能够灵活地应对不同类型的进程和不同的工作负载，同时可以避免长时间运行的进程占用CPU资源，提高了系统的响应速度。然而，多级反馈队列调度算法也需要维护多个队列，增加了系统的复杂度。

更详细的可以查看：操作系统进程调度策略

进程同步有哪几种机制？

进程同步是指在多进程或多线程环境中，协调它们的执行顺序和共享资源的访问，以避免出现竞态条件（Race Condition）、死锁（Deadlock）等并发编程中常见的问题。以下是几种常见的进程同步机制：

1. 信号量（Semaphores）：信号量是一种计数器，用于控制对共享资源的访问。它可以有两种类型：二进制信号量（Binary Semaphores）和计数信号量（Counting Semaphores）。通过对信号量的操作（等待和发送信号），进程可以实现对共享资源的互斥访问和同步。
2. 互斥锁（Mutex）：互斥锁是一种用于保护共享资源的锁机制。每次只有一个进程或线程可以持有互斥锁，并且在持有锁的进程释放之前，其他进程无法访问共享资源。这样可以确保对共享资源的互斥访问，避免了竞态条件的发生。
3. 条件变量（Condition Variables）：条件变量是一种用于进程间通信的同步机制。它通常与互斥锁一起使用，用于在某个条件满足时唤醒等待的线程。条件变量允许线程在等待某个条件成立时挂起，并在条件满足时被唤醒，从而避免了忙等待（Busy Waiting）的情况。
4. 屏障（Barrier）：屏障是一种用于同步多个线程的同步机制。当所有线程都到达某个指定的点时，屏障才会打开，允许线程继续执行。屏障可以用于确保所有线程都完成了某个阶段的工作，然后再进行下一阶段的操作。
5. 读写锁（Read-Write Lock）：读写锁允许多个线程同时读取共享资源，但在写入时需要独占访问。这种机制适用于读操作频繁、写操作较少的场景，可以提高并发性能。

有锁的出现就会有死锁

什么是死锁？死锁产生的条件是什么？

死锁（Deadlock）是指在多个进程或线程之间，彼此持有对方所需资源而无法继续执行的情况，导致所有参与者都陷入了无法解脱的僵局状态。在死锁中，每个进程都在等待其他进程释放资源，而无法释放自己所持有的资源，从而导致所有进程都无法向前推进。

死锁产生的四个必要条件是：

1. 互斥条件（Mutual Exclusion）：至少有一个资源必须是被独占的，即一次只能被一个进程使用。这意味着当一个进程持有了某个资源时，其他进程必须等待。
2. 请求与保持条件（Hold and Wait）：进程持有至少一个资源，并且正在等待获取另一个正在被其他进程持有的资源。这意味着当进程在等待某个资源时，它仍然保持着已经获取的资源。
3. 不可抢占条件（No Preemption）：资源不能被抢占，只能在进程完成对资源的使用后自愿释放。这意味着只有持有资源的进程可以主动释放它，而不能被其他进程强行抢占。
4. 循环等待条件（Circular Wait）：存在一个进程等待序列，其中每个进程都在等待下一个进程所持有的资源，形成一个循环。这意味着系统中存在一个进程资源的循环链，每个进程都在等待下一个进程所占用的资源。

当以上四个条件同时满足时，就会导致死锁的发生。为了避免死锁，需要破坏其中一个或多个必要条件，或者采取预防、避免、检测和恢复等死锁处理策略。

死锁的处理基本策略和常用放方法

1. 预防死锁（Deadlock Prevention）：
   • 破坏死锁产生的必要条件之一。常用的方法包括：
     • 破坏互斥条件：允许多个进程共享资源，例如使用读写锁而不是互斥锁。
     • 破坏请求与保持条件：要求一个进程在申请资源时必须释放已经持有的所有资源，然后重新申请所需的资源。
     • 破坏不可抢占条件：当一个进程请求资源时，如果该资源已被其他进程持有，那么请求进程可以被阻塞或者资源的持有者被强制释放资源。
     • 破坏循环等待条件：对资源进行编号，要求进程按编号递增的顺序请求资源，从而避免循环等待。
2. 避免死锁（Deadlock Avoidance）：
   • 在资源分配前，通过动态地检查系统状态，判断是否存在安全的资源分配序列。如果存在安全序列，则分配资源；否则，进程等待直到分配资源不会导致死锁。
   • 常用的算法包括银行家算法（Banker’s Algorithm）和资源分配图（Resource Allocation Graph）。
3. 检测死锁（Deadlock Detection）：
   • 允许死锁发生，但是周期性地检测系统中是否存在死锁。如果检测到死锁，则采取措施解除死锁。
   • 常用的方法是使用资源分配图（Resource Allocation Graph）或者进程等待图（Process Wait-for Graph）来检测死锁。
4. 恢复死锁（Deadlock Recovery）：
   • 当检测到死锁时，通过终止某些进程、回收资源或者进行进程挂起和恢复等方式来解除死锁。
   • 恢复死锁的方法包括进程终止、资源剥夺、进程回退和资源回收等。

选择适当的死锁处理策略取决于系统的特点、对性能的要求以及实现的复杂性。通常情况下，预防和避免死锁是首选，因为它们可以在设计阶段或者运行时减少死锁的发生，而检测和恢复死锁是一种备用的解决方案，用于处理无法避免的死锁情况。

今天就分享到这里，之后会持续间断更新的；