操作系统思维导图

这是一篇关于操作系统的思维导图。操作系统是管理计算机硬件资源，控制其他程序运行并为用户提供交互操作界面的系统软件的集合。

操作系统

• 简单说下你对并行和并发的理解？
  • 1.并行是指两个或多个事件在同一时刻发生 ；而并发是指两个或多个事件在同一时间间隔发生。
  • 2.并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。
• 同步、异步、阻塞、非阻塞的概念
  • 同步
    • 当一个同步调用发出后，调用者要一直等待返回结果。通知后，才能进行后续的执行。
  • 异步
    • 当一个异步过程调用发出后，调用者不能立刻得到返回结果。实际处理这个调用的部件在完成后，通过状态、通知和回调 来通知调用者。
  • 阻塞
    • 是指调用结果返回前，当前线程会被挂起，即阻塞。
  • 非阻塞
    • 是指即使调用结果没返回，也不会阻塞当前线程。
• 什么是缓冲区溢出？有什么危害
  • 缓冲区为暂时置放输出或输入资料的内存。缓冲区溢出是指当计算机向缓冲区填充数据时超出了缓冲区本身的容量，溢出的数据覆盖在合法数据上造成缓冲区溢出，缓冲区溢出的主要原因是程序中没有仔细检查用户输入是否合理。计算机中，缓冲区溢出会造成的危害主要有以下两点：程序崩溃导致拒绝服务和跳转并且执行一段恶意代码。
• 物理地址、逻辑地址、虚拟内存的概念
  • 物理地址
    • 它是地址转换的最终地址，进程在运行时执行指令和访问数据最后都要通过物理地址从主内存中存取，是内存单元真正的地址。
  • 逻辑地址
    • 是计算机用户看到的地址。例如：当创建一个长度为100的整型数组时，操作系统返回一个逻辑上的连续空间：指针指向数组第一个元素的内存地址。由于整型元素的大小为4个字节，故第二个元素的地址时起始值加4，以此类推。事实上，逻辑地址并不一定是元素存储的真实地址，即数组元素的物理地址（在内存条中所处的位置），并非是连续的，只是操作系统通过地址映射，将逻辑地址映射成连接的，这样更符合人们的直观思维。
  • 虚拟内存
    • 是计算机系统内存管理的一种技术。它使得应用程序认为它拥有连续的可用内存（一个连续完整的地址空间），而实际上，它通常被分隔成多个物理内存片，还有部分暂时存储在外部磁盘存储器上，在需要时进行数据交换。
• 页面置换算法有哪些
  • 请求调页，也称按需调页，即对不在内存中的“页”，当进程执行时要用时才调入，否则有可能到程序结束时也不会调入。而内存中给页面留的位置是有限的，在内存中以帧为单位放置页面。为了防止请求调页的过程出现过多的内存页面错误（即需要的页面不在内存中，需要从硬盘中读数据，以及需要做页面的替换）而使得程序执行效率下降，我们需要设计一些页面置换算法，页面按照这些算法进行相互替换时，可以尽量达到较低的错误率。常用的页面置换算法如下：
    • 先进先出置换算法（FIFO）
      • 先进先出，即淘汰最早调入的页面
    • 最佳置换算法（OPT）
      • 选未来最远将使用的页淘汰，是一种最优的方案，可以证明缺页数最小。
    • 最近最久未使用（LRU）算法
      • 即选择最近最久未使用的页面予以淘汰
    • 时钟（CLOCK)置换算法
      • 时钟置换算法也叫最近未用算法NRU(Not RecentlyUsed）。该算法为每个页面设置一位访问位，将内存中的所有页面都通过链接指针连成一个循环队列。
• 谈谈你对动态链接库和静态链接库的理解
  • 静态链接就是在编译链接时直接将需要的执行代码拷贝到调用处，优点就是在程序发布的时候就不需要依赖库，也就是不再需要带着库一块发布，程序可以独立执行，但是体积可能会相对大一些。
  • 动态链接就是在编译的时候不再直接拷贝可执行代码，而是通过记录一系列符号和参数，在程序运行或加载时将这些信息传递给操作系统，操作系统负责将需要的动态库加载到内存中，然后程序在运行到指定的代码时，去共享执行内存中已经加载的动态库可执行代码，最终达到运行时连接的目的。优点是多个程序可以共享同一段代码，而不需要在磁盘上存储多个拷贝，缺点是由于是运行时加载，可能会影响程序的前期执行性能。
• 外中断和异常有什么区别
  • 外中断是指由CPU执行指令以外的事件引起，如I/O完成中断，表示设备输入/输出处理已经完成，处理器能够发送下一个输入/输出请求。此外还有时钟中断、控制台中断。
  • 而异常是由CPU执行指令的内部事件引起，如非法操作码、地址越界、算术溢出等。
• 一个程序从开始运行到结束的完整过程，你能说出来多少？
  • 预编译
    • 主要处理源代码文件中的以“#”开头的预编译指令。处理规则见下
      • 1、删除所有的#define，展开所有的宏定义。
      • 2、处理所有的条件预编译指令，如"#if"、"#endif"、"#ifdef"、"#elif"和"#else"。
      • 3、处理“#include”预编译指令，将文件内容替换到它的位置，这个过程是递归进行的，文件中包含其他文件。
      • 4、删除所有的注释，“//”和/**/"
      • 5、保留所有的#pragma编译器指令，编译器需要用到它们，如#pragma once是为了防止有文件被重复引用。
      • 6、添加行号和文件标识，便于编译时编译器产生调试用的行号信息，和编译时产生编译错误或警告是能够显示行号。
  • 编译
    • 把预编译之后生成的xxx.i或xxx.ii文件，进行一系列词法分析、语法分析、语义分析及优化后，生成相应的汇编代码文件。
      • 1、词法分析：利用类似于“有限状态机”的算法，将源代码程序输入到扫描机中，将其中的字符序列分割成一系列的记号。
      • 2、语法分析：语法分析器对由扫描器产生的记号，进行语法分析，产生语法树。由语法分析器输出的语法树是一种以表达式为节点的树。
      • 3、语义分析：语法分析器只是完成了对表达式语法层面的分析，语义分析器则是对表达式是否有意义进行判断，其分析的语义是静态语义-----在编译期能分析的语义，相对的动态语义是在运行期才能确定的语义。
      • 4、优化：源代码级别的一个优化过程。
      • 5、目标代码生成：由代码生成器将中间代码转换成目标机器代码，生成一系列的代码序列----汇编语言表示。
      • 6、目标代码优化：目标代码优化器对上述的目标机器代码进行优化：寻找合适的寻址方式、使用位移来替代乘法运算、删除多余的指令等。
  • 汇编
    • 将汇编代码变成机器可以执行的指令（机器码文件）。汇编器的汇编过程相对于编译器来说更简单，没有复杂的语法，也没有语义，更不需要做指令优化，只是根据汇编指令和机器指令的对照表一一翻译过来，汇编过程由汇编器as完成。
    • 经汇编之后，产生目标文件（可执行文件格式几乎一样） xxx.o(Linux下）、xxx.obj(Windows下）。
  • 链接
    • 将不同的源文件产生的目标文件进行链接，从而形成一个可以执行的程序。链接分为静态链接和动态链接：
      • 静态链接
        • 函数和数据被编译进一个二进制文件。在使用静态库的情况下，在编译链接可执行文件时，链接器从库中复制这些函数和数据并把它们和应用程序的其它模块组合起来创建最终的可执行文件。空间浪费：因为每个可执行程序中所有需要的目标文件都要有一份副本，所以如果多个程序对同一个目标文件都有依赖，就会出现同一个目标文件都在内存存在多个副本；更新困难：每当函数的代码修改了，这个时候就需要重新进行编译链接形成可执行程序。
        • 运行速度快：但是静态链接的优点就是，在可执行程序中已经具备了所有执行程序所需要的任何东西，在执行的时候运行速度快。
      • 动态链接
        • 动态链接的基本思想是把程序按照模块拆分成各个相对独立部分，在程序运行时才将它们链接在一起形成的一个完整的程序，而不是静态链接一样把所有程序模块都链接成一个单独的可执行文件。
        • 共享库：就是即使需要每个程序都依赖同一个库，但是该库不会像静态链接那样在内存中存在多个副本，而是在多个程序在执行时共享同一份副本。
        • 更新方便：更新时只需要替换原来的目标文件，而无需将所有的程序再重新链接一遍。当程序下一次运行时，新版本的目标文件会被自动加载到内存并且链接起来，程序就完成了升级的目标。
        • 性能损耗：因为把链接推迟到了程序运行时，所以每次执行程序都需要进行链接，所以性能会有一定损失。
• 什么是用户态和内核态
  • 用户态和内核态是操作系统的两种运行状态
    • 内核态：处于内核态的CPU可以访问任意的数据，包括外围设备，比如网卡、硬件等，处于内核态的CPU可以从一个程序切换到另一个程序，并且占用CPU 不会发生抢占状态，一般处于特权级0的状态我们可以称之为内核态。
    • 用户态：处于用户态的CPU只能受限的访问内存，并且不允许访问外围设备，用户态下的CPU不允许独占，也就是说CPU能够被其他程序获取。
  • 为什么要有用户态和内核态呢？
    • 这个主要是访问能力的限制的考量，计算机中有一些比较危险的操作，比如设置时钟，内存清理，这些都需要在内核状态下完成，如果随意进行这些操作，那系统会多次崩溃。
  • 用户态和内核态是如何切换的？
    • 所有的用户进程都是运行在用户态的，但是我们上面也说了，用户进程的访问能力有限，一些比较重要的比如从硬盘读取数据，从键盘获取数据的操作则是内核态才能做的事情，而这些数据却又对用户程序来说非常重要。所以就涉及到两种模式下的转换，即用户态-->内核态-->用户态，而唯一能够做这些操作的只有系统调用，而能够执行系统调用的只有操作系统。
    • 一般用户态-->内核态的转换我们都称之为trap进内核，也被称之为陷进指令。它们的工作流程如下：
    • • 首先用户程序会调用glibc库，glibc是一个标准库，同时也是一套核心库，库中定义了很多关键API。
      • glibc库知道针对不同体系结构调用系统调用的正确方法，它会根据体系结构应用程序的二进制接口设置用户进程传递的参数，来准备系统调用。
      • 然后，glibc库调用软件中断指令（SWI），这个指令通过更新XPSR寄存器将模式改为超级用户模式，然后跳转到地址0x88处。
        • 寄存器https://blog.csdn.net/qq_34157534/article/details/104684935
      • 到目前为止，整个过程仍处于用户态下，在执行SWI指令后，允许进程执行内核代码，MMU现在允许内核虚拟内存访问。
      • 从地址0x88开始，进程执行加载并跳转到中断处理程序，这个程序就是ARM中的vector_swi()
      • 在vector_swi()中，从SWI指令中提取系统调用号SCNO，然后使用SCNO作为系统调用表sys_call_table的索引，调用到系统调用函数。
      • 执行系统调用完成后，将还原到用户模式寄存器，然后再以用户模式执行。
      • glibc库
        • 根据
          • 体系结构应用程序的二进制接口
            • 设置用户进程传递的参数
              • 准备系统调用
        • 调用
          • 软件中断指令（SWI)
            • 更新
              • XPSR寄存器
                • 将模式改为超级用户模式
                  • 跳转到
                    • 地址0x88
                      • 进程执行加载并跳转到中断处理程序
                        • ARM中的vector_swi()
                          • 执行系统调用完成后，将还原到用户模式寄存器，然后再以用户模式执行。
            • 允许进程执行内核状态码
              • MMU现在允许内核虚拟内存访问
• 原子操作是如何实现的
  • 处理器使用基于对缓存加锁或总线加锁的方式来实现处理器之间的原子操作。首先处理器会自动保证基本的内存操作的原子性。处理器保证从系统内存中读取或者写入一个字节是原子的，意思是当一个处理器读取一个字节时，其他处理器不能访问这个字节的内存地址。Pentium6和最新的处理器能够自动保证单处理器对同一个缓存里进行16/32/64位的操作是原子的，但是复杂的内存操作处理器是不能自动保证原子性的，比如跨总线宽度、跨多个缓存和跨页表的访问。但是，处理器提供总线锁定和缓存锁定两个机制来保证复杂内存操作的原子性。
    • （1)使用总线锁定保证原子性，第一个机制是通过总线锁保证原子性。如果多个处理器同时对共享变量进行读写操作（i++就是经典的读写操作），那么共享变量就会被多个处理器同时进行操作，这样读写操作就不是原子性的，操作完之后共享变量的值会和期望的不一致。举个例子，如果i=1，我们进行两次i++操作，我们期望的结果是3，但是有可能结果是2，原因是多个处理器同时从各自的缓存中读取变量i，分别进行加1操作，然后分别写入系统内存中。那么，想要保证读写共享变量的操作是原子性的，就必须保证CPU1读写共享变量的时候，CPU2不能操作缓存了该共享变量内存地址的缓存。
    • 处理器使用总线锁就是用来解决这个问题的。所以总线索就是使用处理器提供的一个LOCK#信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器可以独占共享内存。
  • 使用缓存锁保证原子性 第二个机制是通过缓存锁定来保证原子性。在同一时刻，我们只需保证对某个内存地址的操作是原子性的即可，但总线锁定把CPU和内存之间的通信锁住了，这使得锁定期间，其他处理器不能操作其他内存地址的数据，所以总线锁定的开销比较大，目前处理器在某些场合下使用缓存锁定代替总线锁来进行优化。
    • 频繁使用的内存会缓存在处理器的L1、L2、和L3、高速缓存里，那么原子操作就可以直接在处理器内部缓存中进行，并不需要声明总线程，在Pentium6和目前的处理器中可以使用“缓存锁定”的方式来实现复杂的原子性。
    • 所谓“缓存锁定”是指内存区域如果被缓存在处理器的缓存行中，并且在LOCK操作期间被锁定，那么当它执行锁操作回写到内存时，处理器不在总线上声言LOCK#信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效，在如上图所示的例子中，当CPU1修改缓存行的i时使用了缓存锁定，那么CPU2就不能使用同时缓存的缓存行。
    • 但是有两种情况处理器不会使用缓存锁定。第一种情况是：当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行时则处理器会调用总线锁定。第二种情况是：有些处理器不支持缓存锁定。对于Intel486和Pentium处理器，就算锁定的内存区域在缓存行中也会调用总线锁定。
• 抖动你知道是什么吗？它也叫颠簸现象
  • 刚刚换出 页面马上又要换入内存，刚刚换入的页面马上又要换出外存，这种频繁的页面调度行为称之为抖动，或颠簸。产生抖动的主要原因是进程频繁访问的页面数目高于可用的物理块数（分配给进程的物理块不够）
  • 为进程分配的物理块太少，会使进程发生抖动现象。为进程分配的物理块太多，又会降低系统整体的并发度，降低某些资源的利用率 为了研究应该为每个进程分配多少个物理块，denning提出了进程工作集的概念。
• 内存交换中，被换出的进程保存在哪里？
  • 保存在磁盘中，也就是外存中。具有对换功能的操作系统，通常把磁盘空间分为文件区和对换区两部分。文件区主要用于存放文件，主要追求存储空间的利用率，因此对文件区空间的管理采用离散分配方式；对换区只占磁盘空间的一小部分，被换出的进程数据就存放在对换区。由于对换的速度直接影响到系统的整体速度，因此对换区空间的管理主要追求换入换出速度，因此通常对换区采用连续分配方式。总之，对换区的I/O比文件区的更快。
• 常见内存分配内存错误
  • （1）内存分配未成功，却使用了它
    • 编程新手常犯这种错误，因为他们没有意识到内存分配会不会成功。常用解决办法是，在使用内存之前检查指针是否为NULL。如果指针p是函数的参数，那么在函数的入口处使用assert(p!=NULL)进行检查。如果是用malloc或new来申请内存，应该用if(pNULL)或if(p!=NULL)进行防错处理。
  • （2）内存分配虽然成功，但是尚未初始化就引用它
    • 犯这种错误主要有两个起因：一是没有初始化的观念；而是误以为内存的缺省初值全为0，导致引用初值错误（例如数组）。内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信其有。所以无论用何种方式创建数组，都别忘了赋初始值，即便是赋零值也不可省略，不要嫌麻烦。
  • （3）内存分配成功并且已经初始化，但操作越过了内存边界
    • 例如在使用数组时经常发送下标“多1”或者“少1”的操作。特别实在for循环语句中，循环次数很容易搞错，导致数组越界。
  • （4）忘记了释放内存，造成内存泄露。
    • 含有这种错误的函数每被调用一次就丢失一块内存。刚开始系统的内存充足，你看不到错误。终有一次程序突然挂掉，系统出现提示：内存耗尽。动态内存的申请与释放必须配对，程序中malloc（动态内存分配）与free使用的次数一定要相同，否则肯定有错误（new/delete同理）。
  • （5）释放了内存却继续使用它。常见以下有三种情况
    • 程序的对象调用关系过于复杂，实在难以搞清楚某个对象是否已经释放了内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。
    • 函数的return语句写错了，注意不要返回指向的“栈内存”的指针或“引用”，因为该内存在函数体结束时被自动销毁。
    • 使用free或delete释放了内存后，没有将指针设置为NULL。导致产生“野指针”。
• 进程和线程
  • 进程
    • 进程是系统进行资源分配和调度的一个独立单位，是系统中的并发执行单位。
  • 线程
    • 线程是一个进程的实体，也是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位，有时被称为轻权进程或轻量级进程。
  • 区别
    • 1.进程是资源分配的最小单位，而线程是CPU调度的最小单位。
    • 2.创建进程或撤销进程，系统都要为之分配或回收资源，操作系统开销远大于创建 或撤销线程时的开销。
    • 3.不同进程地址空间相互独立，同一进程内的线程空间共享同一地址空间。一个进程的线程在另一个进程内是不可见的；
    • 4.进程间不会相互影响，而一个线程挂掉将可能导致整个进程挂掉
  • 有了进程，为什么还要有线程呢？
    • 1.进程在同一时间只能干一件事
    • 2.进程在执行的过程中如果阻塞，整个进程就会被挂起，即使进程中有些工作不依赖于等待的资源，仍然不会执行。
    • 基于以上的缺点，操作系统引入了比进程粒度更小的线程，作为并发执行的单位，从而减少程序在并发执行时所付出的时间和空间开销，提高并发性能。
  • 进程的状态转换
    • 进程包括三种状态：就绪状态、运行状态和阻塞状态
      • 就绪-->执行
        • 对就绪状态的进程，当进程调度程序按一种选定的策略从中选中一个就绪进程，为之分配了处理机后，该进程便由就绪状态变为执行状态。
      • 执行-->阻塞
        • 正在执行的进程因发生某等待事件而无法执行，则进程由执行状态变为阻塞状态，如进程提出输入/输出请求而变成等待外部设备传输信息的状态，进程申请资源（主存空间或外部设备）得不到满足时变成等待资源状态，进程运行中出现了故障（程序出错或主存储器读写错等）变成等待干预状态等等。
      • 阻塞-->就绪
        • 处于阻塞状态的进程，在其等待的事件已经发生，如输入、输出完成，资源得到满足或错误处理完毕时，处于等待状态的进程并不马上转入执行状态，而是先转入就绪状态，然后再由系统进程调度程序在适当的时候将进程转为执行状态。
      • 执行-->就绪
        • 正在执行的进程，因时间片用完而被暂停执行，或在采用抢先式优先级调度算法的系统中，当有更高优先级的进程要运行而被迫让出处理机时，该程序便由执行状态变为就绪状态。
  • 进程间通信（IPC）
    • 是指在不同进程之间传播或交换信息，IPC的方式通常有管道（包含无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中Socket和Streams支持不同主机的两个进程IPC。
      • 管道
        • 1.它半双工的，具有固定的读端和写端
        • 2.它只能由于父子进程或兄弟进程之间的进程的通信
        • 3.它可以看出是一种特殊的文件，对于它的读写也可以使用普通的read、write等函数。但是它不是普通的文件，并不属于其他任何文件系统，并且只存在于内存中。
      • 命名管道
        • 1.FIFO可以在无关的进程之间交换数据，与无名管道不同
        • 2.FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。
      • 消息队列
        • 1.消息队列，是消息的链接表，存放在内核中，一个消息队列由一个标识符ID来标识。
        • 2.消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
        • 3.消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除
        • 4.消息队列可以实现消息的随机查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取。
      • 信号量
        • 1.信号量是一个计数器。用于实现进程间的互斥与同步，而不是存储进程间通信数据
        • 2.信号量用于进程间同步，若要在进程间传递数据需要结合共享内存
        • 3.信号量基于操作系统的PV操作，程序对信号量的操作都是原子操作；
        • 4.每次对信号量的PV操作不仅限于对信号量值加1或减1，而且可以加减任意正整数
        • 5.支持信号量组
      • 共享内存
        • 指两个或多个进程共享一个给定的存储区
        • 共享内存是最快的一种IPC，因为进程是直接对内存进行存取的。
  • 进程的调度算法有哪些？
    • 调度算法是指：根据系统的资源分配策略所规定的资源分配算法。常用的调度算法有：先来先服务调度算法、时间片轮转调度法、短作业优先调度法、最短剩余时间优先、高响应比优先调度算法、优先级调度算法等等。
      • 先来先服务调度算法
        • 先来先服务调度算法是一种最简单的调度算法，也称为先进先出或严格排队方案。当每个进程就绪后，它加入就绪队列。当前正运行的进程停止执行，选择在就绪队列中存在时间最长的进程运行。该算法既可以用于作业调度，也可以用于进程调度。先来先去服务比较适合于常作业（进程），而不利于段作业（进程）
      • 时间片轮转调度算法
        • 时间片轮转调度算法主要适用于分时系统。在这种算法中，系统将所有就绪进程按到达时间的先后次序排成一个队列，进程调度程序选择总是选择就绪队列中第一个进程执行，即先来先服务的原则，但仅能运行一个时间片。
      • 短作业优先调度算法
        • 短作业优先调度算法是指对短作业优先调度的算法，从后备队列中选择一个或者若干个估计运行时间最短的作业，将它们调入内存运行。短作业优先调度算法是一个非抢占策略，他的原则是下一次选择预计处理时间最短的进程，因此短进程将会越过长作业，跳至队列头。
      • 最短剩余时间优先调度算法
        • 最短剩余时间是针对最短进程优先增加了抢占机制的版本。 在这种情况下，进程调度总是选择预期剩余时间最短的进程。当一个进程进入到就绪队列时，他可能比当前运行的进程具有更短的剩余时间，因此只要新进程就绪，调度程序就可能抢占当前正在运行的进程。像最短进程优先一样，调度程序正在执行选择函数是必须有关于从处理时间的估计，并且存在长进程饥饿的危险。
      • 高响应比优先调度算法
        • 高响应比优先调度算法主要用于作业调度，该算法是对先来先服务调度算法和短作业优先调度算法的一种综合平衡，同时考虑每个作业的等待时间和估计的运行时间。在每次进行作业调度时，先计算后备作业队列中每个作业的响应比，从中选出响应比最高的作业投入运行。
      • 优先级调度算法
        • 优先级调度算法每次从后备作业队列中选择优先级最高的一个或几个作业，将它们调入内存，分配必要的资源，创建进程并放入就绪队列。在进程调度中，优先级调度算法每次从就绪队列中选择优先级最高的进程，将处理机分配给它，使之投入运行。
  • 死锁
    • 死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都无法向前推进：如果此时有一个线程A，已经持有了锁A，但是试图获取锁B，线程B持有锁B，而试图获取锁A，这种情况下就会产生死锁。
    • 产生死锁的原因？
      • 由于系统中存在一些不可剥夺资源，而当两个或两个以上进程占有自身资源，并请求对方资源时，会导致每一个进程都无法向前推进，这就是死锁。
      • 竞争资源
        • 1.可剥夺资源
          • 是指某进程在获得这类资源后，该资源可以再被其他进程或系统剥夺，CPU和主内存属于可剥夺性资源。
        • 2.不可剥夺资源
          • 当系统把这类资源分配给某进程之后，再不能强行回收，只能在进程用完后自行释放，如磁带机、打印机等。
      • 进程推进顺序不当
        • 例如：进程A和进程B互相等待对方的数据。
    • 死锁产生的必要条件
      • 1.互斥条件
        • 进程要求对所分配的资源进行排他性控制，即在一段时间内某资源仅为一进程所占用。
      • 2.请求和保持条件
        • 当进程因请求资源而阻塞时，对已获得的资源保持不放。
      • 3.不剥夺条件
        • 进程已获得的资源在未使用完之前，不能剥夺，只能在使用完时由自己释放。
      • 4.环路等待条件
        • 在发生死锁时，必然存在一个进程--资源的环形链。
    • 解决死锁的基本方法？
      • 1.预防死锁
        • 1.破坏请求条件：
          • 一次性分配所有资源，这样就不会有请求了。
        • 2.破坏保持条件：
          • 只要有一个资源得不到分配，也不给这个进程分配其他的资源
        • 3.破坏不可剥夺条件：
          • 当某进程获得了部分资源，但得不到其他资源，则释放已占有的资源
        • 4.破坏环路等待条件
          • 系统给每类资源赋予一个编号，每一个进程按编号递增的顺序请求资源，释放则相反。
      • 2.避免死锁
        • 怎么避免死锁
          • 1.安全状态
            • 图 a 的第二列 Has 表示已拥有的资源数，第三列 Max 表示总共需要的资源数，Free 表示还有可以使用的资源数。从图 a 开始出发，先让 B 拥有所需的所有资源（图 b），运行结束后释放 B，此时 Free 变为 5（图 c）；接着以同样的方式运行 C 和 A，使得所有进程都能成功运行，因此可以称图 a 所示的状态时安全的。
            • 定义：如果没有死锁发生，并且即使所有进程突然请求对资源的最大需求，也仍然存在某种调度次序能够使得每一个进程运行完毕，则称该状态是安全的。
            • 安全状态的检测与死锁的检测类似，因为安全状态必须要求不能发生死锁
          • 2.单个资源的银行家算法
            • 一个小城镇的银行家，他向一群客户分别承诺了一定的贷款额度，算法要做的是判断对请求的满足是否会进入不安全状态，如果是，就拒绝请求，否则予以分配。
            • 上图c为不安全状态，因此算法会拒绝之前的请求，从而避免进入图c中的状态。
          • 3.多个资源的银行家算法
            • 上面中有五个进程，四个资源。左边的图表示已经分配的资源，右边的图表示还需要分配的资源。最右边的E、P以及A分别表示：总资源、已分配资源以及可用资源，注意这三个为向量，而不是具体数值，例如A=（1020），表示4个资源分别剩下1/0/2/0
            • 检查一个状态是否安全的算法如下：
              • 查找右边的矩阵是否存在一行小于等于向量A。如果不存在这样的行，那么系统就会发生死锁，状态是不安全的。
              • 假若找到这样一行，将该进程标记为终止，并将其已分配资源加到A中。
              • 重复以上两步，直到所有进程都标记为终止，则状态是安全的。
            • 如果一个状态不是安全的，需要拒绝进入这个状态。
      • 3.检测死锁
      • 4.解除死锁
        • 怎么解除死锁？
          • 1.资源剥夺：挂起某些死锁进程，并抢占它的资源，将这些资源分配给其他死锁进程（但应该防止被挂起的进程长时间得不到资源）
          • 2.撤销进程：强制撤销部分、甚至全部死锁进程并剥夺这些进程的资源（撤销的原则可以按优先级和撤销进程代价的高低进行）；
          • 3.进程回退：让一个或多个进程回退到足以避免死锁的地步。进程回退时自愿释放资源而不是被剥夺。要求系统保持进程的历史信息，设置还原点。
  • 进程的终止
    • 进程在创建之后，它就开始允许并做完成任务。然而，没有什么事儿是永不停歇的，包括进程也一样。进程早晚会发送终止，但是通常是由于以下情况触发的。
      • 正常退出（自愿的）
        • 多数进程是由于完成了工作而终止。当编译器完成了所有给定程序的编译之后，编译器会执行一个系统调用告诉操作系统它完成了这个工作。这个调用在unix中是exit，在Windows中是ExitProcess。面向屏幕中的软件也支持自愿终止操作。字处理软件、Internet浏览器和类似的程序中总有一个供用户点击的图标或菜单项，用来通知进程删除它所打开的任何临时文件。
      • 错误退出（自愿的）
        • 进程发生终止的第二个原因是发现严重错误，例如，如果用户执行了如下命令 cc foo.c 为了能够编译foo.c 但是该文件不存在，于是编译器就会发出声明并推出。在给出了错误参数时，面向屏幕的交互式进程通常不会直接退出，因为这从用户的角度来说并不合理，用户需要知道发生了什么并想要进行重试，所以这时候应用程序通常会弹出一个对话框告知用户发生了系统错误，是需要重试还是退出。
      • 严重错误（非自愿的）
        • 进程终止的第三个原因是由进程引起的错误，通常是由于程序中的错误所导致的。例如，执行了一条非法指令，通常是由于程序中的错误所导致的。例如，执行了一条非法指令，引用不存在的内存，或者除数是0等。还有些系统比如UNIX中，进程可以通知操作系统，它希望自行处理某种类型的错误，在这类错误中，进程会收到信号（中断），而不是在这类错误出现时直接终止进程。
      • 被其他进程杀死（非自愿的）
        • 第四个终止进程的原因是，某个进程执行系统调用告诉操作系统杀死某个进程。在UNIX中，这个系统调用是kill。在win32中对应的函数是TerminateProcess（注意不是系统调用）。
  • 守护进程、僵尸进程和孤儿进程
    • 守护进程
      • 指在后台运行的，没有控制终端与之相连的进程。它独立于控制终端，周期性的执行某种任务。Linux的的大多数服务器就是用守护进程的方式实现的，如web服务器进程http等。
        • 创建守护进程的要点
          • （1）让程序在后台执行，方法是调用fork()产生一个子进程，然后使父进程退出。
          • （2）调用setsid()创建一个新对话期。控制终端、登录会话和进程组通常是从父进程继承下来的，守护进程要摆脱它们，不受它们的影响，方法是调用setsid()使进程成为一个会话组长。setsid()调用成功后，进程成为新的会话组长和进程组长，并与原来的登录会话、进程组和控制终端脱离。
          • （3）禁止进程重新打开控制终端。经过以上步骤，进程已经成为一个无终端的会话组长，但是它可以重新申请打开一个终端。为了避免这种情况发生，可以通过使进程不再是会话组长来实现，再一次通过fork（）创建新的子进程，使调用fork的进程退出。
          • （4）关闭不再需要的文件描述符。子进程从父进程继承打开的文件描述符。如不关闭，将会浪费系统资源，造成进程所在的文件系统无法卸下以及引起无法预料的错误。首先获得最高文件描述符值，然后用一个循环程序，关闭0到最高文件描述符值的所有文件描述符。
          • （5）将当前目录更改为根目录。
          • （6）子进程从父进程继承的文件创建屏幕字可能会拒绝某些许可权。为防止这一点，使用unmask(0)j将屏蔽字清零。
          • （7）处理SIGCHLD信号。对于服务器进程，在请求到来时往往生成子进程处理请求。如果子进程等待父进程捕获状态，则子进程将成为僵尸进程，从而占用系统资源。如果父进程等待子进程结束，将增加父进程的负担，影响服务器进程的并发性能。在Linux下可以简单地将SIGGHLD信号的操作设为SIG_IGN。这样，子进程结束时不会产生僵尸进程。
    • 孤儿进程
      • 如果父进程先退出，子进程还没退出，那么子进程的父进程将变为init进程。（注：任何一个 进程都必须有父进程）。
      • 一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程（进程号为1）所收养，并由init进程对它们状态收集工作。
    • 僵尸进程
      • 如果子进程先退出，父进程还没退出，那么子进程必须等到父进程捕获到子进程的退出状态才真正结束，否则这个时候子进程就成为僵尸进程。
      • 设置僵尸进程的目的是维护子进程的信息，以便父进程在以后某个时候获取。这些信息至少包括进程ID,进程的终止状态，以及进程使用的CPU时间，所以当终止子进程的父进程调用wait或waitpid时就可以得到这些信息。如果一个进程终止，而该进程有子进程处于僵尸状态，那么它的所有僵尸子进程ID将被重置为1（init进程）。继承这些子进程的init进程将清理它们（也就是说init进程将wait它们，从而去除它们的僵尸状态）。
      • 如何避免僵尸进程
        • 通过signal(SIGCHILD,SIG_IGN)通知内核对子进程的结束不关心，由内核回收。如果不想让父进程挂机，可以在父进程中加入一条语句：signal（SIGCHILD,SIG_IGN);表示父进程忽略SIGCHILD信号，该信号是子进程退出的时候向父进程发送的。
        • 父进程调用wait/waitpid等函数等待子进程，如果尚无子进程退出wait会导致父进程阻塞。waitpid可以通过传递WNOHANG使父进程不阻塞立即返回。。
        • 如果父进程很忙可以用signal注册信号处理函数 ，在信号处理函数调用wait/waitpid等待子进程退出。
        • 通过两次调用fork。父进程首先调用fork创建一个子进程然后waitpid等待子进程退出，子进程再fork一个孙进程后退出。这样子进程退出后会被父进程等待回收，而对于孙子进程其父进程已经退出所以孙进程成为一个孤儿进程，孤儿进程由init进程接管，孙进程结束后，init会等待回收。
        • 第一种方法忽略SIGCHILD信号，这常用于并发服务器的性能的一个技巧因为并发服务器常常fork很多子进程，子进程终结之后需要服务器进程去wait清理资源。如果将此信号的处理方式设为忽略，可以让内核把僵尸进程交给init进程去处理，省去了大量僵尸进程占用系统资源。
  • 锁
    • 介绍几种典型的锁
      • 读写锁
        • 多个读者可以同时进行读
        • 写者必须互斥（只允许一个写者写，也不能读者写者同时进行）
        • 写者优先于读者（一旦有写者，则后续读者必须等待，唤醒时优先考虑写者)
      • 互斥锁
        • 一次只能一个线程拥有互斥锁，其他线程只有等待
        • 互斥锁是在抢锁失败的情况下主动放弃CPU进入睡眠状态直到锁的状态改变时再唤醒，而操作系统复责线程调度，为了实现锁的状态发生改变时唤醒阻塞的线程或者进程，需要把锁交给操作系统管理，所以互斥锁在加锁操作时涉及上下文的切换。互斥锁实现的效率还是可以让人接受的，加锁的时间大概100ns左右，而实际上互斥锁的一种可能的实现是先自旋一段时间，当自旋的时间超过阈值之后再将线程投入睡眠中，因此在并发运算中使用互斥锁（每次占用锁的时间很短）的效果可能不亚于使用自旋锁。
      • 条件变量
        • 互斥锁一个明显的缺点是他只有两种状态：锁定和非锁定。而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，他常和互斥锁一起使用，以免出现竞态条件。当条件不满足时，线程往往解开相应的互斥锁并阻塞线程然后等待条件发生变化。一旦其他的某个线程改变了条件变量，他将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。总的来说互斥锁是线程间互斥的机制，条件变量则是同步机制。
      • 自旋锁
        • 如果进线程无法取得锁，进线程不会立刻放弃CPU时间片，而是一直循环尝试获取锁，直到获取为止。如果别的线程长时间占有锁，那么自旋锁就是在浪费CPU做无用功，但是自旋锁一般应用于加锁时间很短的场景，这个时候效率比较高。