计算机操作系统（八）——并发程序设计

并发程序设计

顺序程序设计

1. 程序是实现算法的操作（指令）序列
2. 每个程序在处理器上执行是严格有序的，称为程序执行的内部顺序性
3. 程序设计的一般习惯是顺序程序设计
   
   1. 把一个具体问题的求解过程设计成一个程序或者若干严格顺序执行的程序序列，称为程序执行的外部顺序性
4. 特性：
   
   1. 程序执行的顺序性：程序指令执行是严格按序的
   2. 计算环境的封闭性：程序运行时如同独占受操作系统保护的资源
   3. 计算结果的确定性：程序执行结果与执行速度和执行时段无关
   4. 计算过程的可再见性：程序对相同数据集的执行轨迹是确定的

进程的并发执行

1. 多道程序设计让多个程序同时进入内存去竞争处理器以获得运行机会
2. OS允许计算机系统在一个时间段内存在多个正在运行的进程，即允许多个进程并发执行
3. OS保证按照“顺序程序设计”方法编程的程序在并发执行时不受影响，如同独占计算机
4. 这些按照顺序程序设计思想编程的进程在OS中并发执行属于无关的并发进程

处理器利用率计算

1. 顺序程序设计：input（78s）、process（52s）、output（20s），52/(78+52+20)=35%
2. 并发程序设计：时间同上，while(1){input,send}; while(1){receive,process,send}; while(1){receive,output}，(52*n)/(78*n+52+20)=67%，n趋近于无穷大

并发程序设计

把一个具体问题求解设计成若干个可同时执行的程序模块的方法

特性：

1. 并发性：多个进程在多道程序系统中并发执行或者在多处理器系统中并行执行：提高了计算效率
2. 共享性：多个进程共享软件资源
3. 交往性：多个进程并发执行时存在制约：增加了程序设计的难度

无关与交往的并发进程

1. 无关：一组并发进程分别在不同变量集合上运行，一个进程的执行与其他并发进程的进展无关
2. 交往：一组并发进程共享某些变量，一个进程的执行可能影响其他并发进程的结果

与时间有关的错误

1. 对于一组交往的并发进程，执行的相对速度无法相互控制
2. 如果程序设计不当，可能出现各种“与时间有关的”错误
3. 表现一：结果错误；表现二：永远等待

进程互斥与进程同步

1. 交互的并发进程在执行时必须进行制约，才能保证得到合理的结果
2. 进程互斥：并发进程之间因相互争夺独占性资源而产生的竞争制约关系
3. 进程同步：并发进程之间为完成共同任务基于某个条件来协调执行先后关系而产生的协作制约关系

互斥与临界区

1. 临界资源：互斥共享变量所代表的资源，即一次只能被一个进程使用的资源

2. 临界区：并发进程中与互斥共享变量相关的程序段

   1. 确定临界资源 share
   2. 确定临界区 region do
   3. 两个进程的临界区有相同的临界资源，就是相关的临界区，必须互斥进入
   4. 两个临界区不相关，进入就没有限制
   5. 临界区管理的三个要求
      
      1. 一次至多允许一个进程停留在相关的临界区内
      2. 一个进程不能无限止地停留在临界区内
      3. 一个进程不能无限止地等待进入临界区

   6. 临界区管理

      1. 同时进入临界区

         process P1
           begin
             while inside2 do [ ];
         inside1 := true;
         临界区;
         inside1 := false;
         end;
         
         process P2
           begin
             while inside1 do [ ];
         inside2 := true;
         临界区;
         inside2 := false;
         end;

      2. 同时等待进入临界区

         process P1
           begin
             inside1 := true;
         while inside2 do [ ];
         临界区;
         inside1 := false;
         end;
         
         process P2
           begin
             inside2 := true;
         while inside1 do [ ];
         临界区;
         inside2 := false;
         end;

   7. 解决思路
      c
// 测试锁
TS(x) {
if (x==false) {x=true;return true;
} else return false;
}
Boolean lock;
lock=false; // 临界区可用
process Pi {
Boolean pi;
repeat pi=TS(lock) until pi; // 循环请求锁
临界区
lock=false; // 解锁
}
// 交换锁
swap(a, b){temp=a;a=b;b=temp;}
Boolean lock;
lock=false; // 临界区可用
process Pi {
Boolean pi;
pi=true;
repeat swap(lock, pi) until !pi; // 循环建立锁
临界区;
lock=false; // 解锁
}

   8. 实现临界区管理的硬件设施
      
      1. TS和swap指令均是忙式等待，效率低
      2. 简单的解决办法是在进出临界区时开关中断，这样临界区执行就不会中断了，执行就有原子性。关中断；临界区；开中断
      3. 操作系统原语就采用这种实现思路
      4. 但是，临界区的指令长度应该是短小精悍，这样才能保证系统效率
      5. 不建议用户程序使用，滥用是可怕的！
3. 多个并发进程访问临界资源时，存在竞争制约关系。如果两个进程同时停留在相关的临界区内就会出现与时间相关的错误

PV操作与进程互斥

问题

1. TS或swap指令管理临界区，采用忙式轮询，效率低
2. 关开中断管理临界区，不便交给用户程序使用

信号量的构思

1. 一种可动态定义的软件资源：信号量
   
   1. 核心数据结构：等待进程队列
   2. 信号量声明：资源报到，建立队列
   3. 申请资源的原语：若申请不到，调用进程入队等待
   4. 归还资源的原语：若队列中有等待进程，需释放
   5. 信号量撤销：资源注销，撤销队列

2. 记录型信号量：一种带数值的软资源

   typedef struct semaphore {
       int value;          // 信号量值
       struct pcb *list;   // 信号量等待进程队列指针
   }

   1. 每个信号量建立一个等待进程队列
   2. 每个信号量相关一个整数值
      
      1. 正值表示资源可复用次数
      2. 0值表示无资源且无进程等待
      3. 负值表示等待队列中进程个数
   3. P、V操作原语
      c
procedure P(semaphore:s) {
s -= 1; // 信号量-1
if (s<0) W(s); // 若信号量小于0，则调用进程被置成等待信号量s的状态
}
procedure V(semaphore:s) {
s += 1; // 信号量+1
if (s<=0) R(s); // 若信号量小于等于0，则释放一个等待信号量s的进程
}

   4. PV操作解决进程互斥问题框架
      c
semaphore s;
s=1;
begin
process Pi {
......
P(s);
临界区;
V(s);
......
}
end;


   5. PV操作解决进程同步问题

      1. 进程同步：并发进程为完成共同任务基于某个条件来协调执行先后关系而产生的协作制约关系
      2. 一个进程的执行等待来自于其他进程的消息
      3. 解决的基本思路：
         
         1. 定义一个信号量：其数值代表可用消息数
         2. 等待消息进程：执行P，无消息则等待
         3. 发出消息进程：执行V，有等待进程则释放
         </