Chapter 7 Process Synchronization 进程同步 n 7 1

Chapter 7: Process Synchronization 进程同步 n 7. 1 Background n 7. 2 The Critical-Section Problem n 7. 3 Synchronization Hardware n 7. 4 Semaphores n n n 背景临界区问题同步的硬件实现信号量 7. 5 Classical Problems of Synchronization 经典同步问题 7. 6 Critical Regions 临界区 7. 7 Monitors 管程 7. 8 OS Synchronization 操作系统的同步机制 7. 9 Atomic Transactions 原子事务处理 Operating System Concepts 7. 1 Silberschatz, Galvin and Gagne 2002

7. 1 Background 背景 n Concurrent access to shared data may result in data inconsistency. 对共享数据的并发访问可能导致数据的不一致性 n Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes. 要保持数据的一致性，就需要一种保证并发进程的正确执行顺序的机制 Operating System Concepts 7. 2 Silberschatz, Galvin and Gagne 2002

Background (Cont. ) n Shared-memory solution to bounded-butter problem (Chapter 4) allows at most n – 1 items in buffer at the same time. A solution, where all N buffers are used is not simple. 第 4章中解决有限缓冲区问题的共享内存方法…N项的缓冲器最多只能使用n-1项 n Suppose that we modify the producer-consumer code by adding a variable counter, initialized to 0 and incremented each time a new item is added to the buffer 假定我们通过增加一个计数器变量修改生产者-消费者代码，初始值为 0，在缓冲区增加一个项目（数据）计数器加 1 Operating System Concepts 7. 3 Silberschatz, Galvin and Gagne 2002

$Bounded-Buffer 有界缓冲区 n Shared data #define BUFFER_SIZE 10 typedef struct {. . . }$

Bounded-Buffer 有界缓冲区 n Shared data #define BUFFER_SIZE 10 typedef struct {. . . } item; item buffer[BUFFER_SIZE]; int in = 0; int out = 0; int counter = 0; Operating System Concepts 7. 4 Silberschatz, Galvin and Gagne 2002

Bounded-Buffer (Cont. -1) n Producer process item next. Produced; while (1) { while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = next. Produced; in = (in + 1) % BUFFER_SIZE; counter++; } Operating System Concepts 7. 5 Silberschatz, Galvin and Gagne 2002

Bounded-Buffer (Cont. -2) n Consumer process item next. Consumed; while (1) { while (counter == 0) ; /* do nothing */ next. Consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; } Operating System Concepts 7. 6 Silberschatz, Galvin and Gagne 2002

Bounded Buffer (Cont. -3) n The statements counter++; counter--; must be performed atomically. n Atomic operation means an operation that completes in its entirety without interruption. Operating System Concepts 7. 7 Silberschatz, Galvin and Gagne 2002

Bounded Buffer (Cont. -4) n The statement “count++” may be implemented in machine language as: register 1 = counter register 1 = register 1 + 1 counter = register 1 n The statement “count—” may be implemented as: register 2 = counter register 2 = register 2 – 1 counter = register 2 Operating System Concepts 7. 8 Silberschatz, Galvin and Gagne 2002

Bounded Buffer (Cont. -5) n If both the producer and consumer attempt to update the buffer concurrently, the assembly language statements may get interleaved. 如果生产者和消费者并发地更新缓冲区, 汇编语言语句可以得到的交替存取 n Interleaving depends upon how the producer and consumer processes are scheduled. 交替取决于生产者和消费者进程如何调度 Operating System Concepts 7. 9 Silberschatz, Galvin and Gagne 2002

Bounded Buffer (Cont. -6) n Assume counter is initially 5. One interleaving of statements is: producer: register 1 = counter (register 1 = 5) producer: register 1 = register 1 + 1 (register 1 = 6) consumer: register 2 = counter (register 2 = 5) consumer: register 2 = register 2 – 1 (register 2 = 4) producer: counter = register 1 (counter = 6) consumer: counter = register 2 (counter = 4) n The value of count may be either 4 or 6, where the correct result should be 5. Operating System Concepts 7. 10 Silberschatz, Galvin and Gagne 2002

Race Condition竞争条件 n Race condition: The situation where several processes access and manipulate shared data concurrently. The final value of the shared data depends upon which process finishes last. Outcome of execution depends on the particular order in which the access takes place. 竞争条件：若干进程并发地访问并且操纵共享数据的情况。共享数据的值取决于哪个进程最后完成 n To prevent race conditions, concurrent processes must be synchronized. 防止竞争条件，并发进程必须被同步 Operating System Concepts 7. 11 Silberschatz, Galvin and Gagne 2002

7. 2 The Critical-Section Problem 临界区问题 n n processes all competing to use some shared data 所有n 个进程竞争使用一些共享的数据。 n Each process has a code segment, called critical section, in which the shared data is accessed. 每个进程有一个代码段, 称为临界区, 在那儿共享数据被访问. 临界区：访问临界资源的那段代码 n Problem – ensure that when one process is executing in its critical section, no other process is allowed to execute in its critical section. 问题- 保证当一个进程正在临界区执行时，没有另外的进程进入临界区执行 n 多个进程共享临界资源时必须互斥使用 Operating System Concepts 7. 12 Silberschatz, Galvin and Gagne 2002

临界资源多道程序环境－>进程之间存在资源共享，进程的运行时间受影响硬件或软件（如外设、共享代码段、共享数据结构），多个进程在对其进行访问时（关键是进行写入或修改），必须互斥地进行－－有些共享资源可以同时访问，如只读数据 n 进程间资源访问冲突 F 共享变量的修改冲突 F 操作顺序冲突 n 进程间的制约关系 F 间接制约：进行竞争－－独占分配到的部分或全部共享资源，“互斥” F 直接制约：进行协作－－等待来自其他进程的信息，“同步” n 临界资源: 一次只允许一个进程使用(访问)的资源。如：硬件打印机、磁带机等，软件的消息缓冲队列、变量、数组、缓冲区等。 Operating System Concepts 7. 13 Silberschatz, Galvin and Gagne 2002

Solution to Critical-Section Problem must satisfy 解决临界区问题需满足 1. Mutual Exclusion: If process Pi is executing in its critical section, then no other processes can be executing in their critical sections. 互斥：假定进程Pi在其临界区内执行，其他任何进程将被排斥在自己的临界区之外. 2. Progress：If no process is executing in its critical section and there exist some processes that wish to enter their critical section, then the selection of the processes that will enter the critical section next cannot be postponed indefinitely. 有空让进：临界区虽没有进程执行，但有些进程需要进入临界区，不能无限期地延长下一个要进入临界区进程的等待时间. Operating System Concepts 7. 14 Silberschatz, Galvin and Gagne 2002

Solution to Critical-Section Problem must satisfy (Cont. ) 3. Bounded Waiting: A bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has made a request to enter its critical section and before that request is granted. 有限等待: 在一个进程提出进入临界区的请求和该请求得到答复的时间内，其他进程进入临界区前的等待时间必须是有限的. Assume that each process executes at a nonzero speed 假定每个进程都以非零的的速率执行. No assumption concerning relative speed of the n processes. 没有任何关于这n个进程相对执行速率的假定 Operating System Concepts 7. 15 Silberschatz, Galvin and Gagne 2002

同步机制应遵循的准则 l 空闲让进。当无进程进入临界区时，相应的临界资源处于空闲状态，因而允许一个请求进入临界区的进程立即进入自己的临界区。 l 忙则等待(互斥）。当已有进程进入自己的临界区时，即相应的临界资源正被访问，因而其它试图进入临界区的进程必须等待，以保证进程互斥地访问临界资源。 l 有限等待。对要求访问临界资源的进程，应保证进程能在有限时间进入临界区，以免陷入“饥饿”状态。 l 让权等待。当进程不能进入自己的临界区时，应立即释放处理机，以免进程陷入忙等。 Operating System Concepts 7. 16 Silberschatz, Galvin and Gagne 2002

解释: 使用临界区的原则 n 每次只允许一个进程处于它的临界区(CS)中 n 若有多个进程同时想进入CS, 应在有限时间内让 n n 其中一个进程进入CS, 以免阻塞进程在CS内只能逗留有限时间不应使要进入CS的进程无限期地等待在CS之外的进程不可以阻止其他进程进入CS 不要预期和假定进程进展的相对速度以及可用的处理器数目. 因为这是不可预期的. Operating System Concepts 7. 17 Silberschatz, Galvin and Gagne 2002

Fig 7. 1 General structure of a typical process Pi n General structure of process Pi (other process Pj) n n n do { entry section 进入区 critical section 临界区 exit section 退出区 reminder section 剩余区 } while (1); 临界区(critical section)：进程中访问临界资源的一段代码。进入区(entry section)：在进入临界区之前，检查可否进入临界区的一段代码。如果可以进入临界区，通常设置相应"正在访问临界区"标志退出区(exit section)：用于将"正在访问临界区"标志清除。剩余区(remainder section)：代码中的其余部分。 Processes may share some common variables to synchronize their actions. Operating System Concepts 7. 18 Silberschatz, Galvin and Gagne 2002

7. 2. 1 Two-Process Solutions Algorithm 1 （软件方法） n Only 2 processes, P 0 and P 1 n Shared variables: F int turn; initially turn = 0 F turn = i Pi can enter its critical section ( j=1 -i) n Process Pi do { while (turn != i) ; critical section turn = j; reminder section } while (1); n Satisfies mutual exclusion, but not progress(不满足有空让进条件 ) Operating System Concepts 7. 19 Silberschatz, Galvin and Gagne 2002

n 问题: F 必须轮流使用临界区 F 如果一个进程失败, 另一个进程将被永久阻塞 n 缺点：强制轮流进入临界区，没有考虑进程的实际需要。容易造成资源利用不充分：在Pi出让临界区之后，Pj使用临界区之前，Pi不可能再次使用临界区； Operating System Concepts 7. 20 Silberschatz, Galvin and Gagne 2002

7. 2. 1. 2 Algorithm 2 n Shared variables F boolean flag[2]; initially flag [0] = flag [1] = false. F flag [i] = true Pi ready to enter its critical section n Process Pi do { flag[i] : = true; while (flag[j]) ; critical section flag [i] = false; remainder section } while (1); n Satisfies mutual exclusion, but not progress requirement (see next page). Operating System Concepts 7. 21 Silberschatz, Galvin and Gagne 2002

7. 2. 1. 2 Algorithm 2 n not progress requirement： if 两个进程在执行while语句前, 同时执行了: T 0: P 0 sets flag[0] : = true T 1: P 1 sets flag[1] : = true then P 0 and P 1 are looping forever in their respective while statements! n 也即： Pi和Pj可能都进入不了临界区。当 Pi执行了flag[i] : = true后， Pj执行了 flag[j] : = true，这样两个进程都无法进入临界区 Operating System Concepts 7. 22 Silberschatz, Galvin and Gagne 2002

Algorithm 2 -1 n Shared variables F boolean flag[2]; initially flag [0] = flag [1] = false. F flag [i] = true Pi enter its critical section n Process Pi do { while (flag[j]) ; { flag[i] : = true; critical section} flag [i] = false; remainder section } while (1); n Satisfies mutual exclusion, but not progress requirement. n Pi和Pj可能同时进入临界区。当 Pi执行了while (flag[j])后，Pj执行while (flag[i]) ，这样两个进程同时进入了临界区 Operating System Concepts 7. 23 Silberschatz, Galvin and Gagne 2002

7. 2. 1. 3 Algorithm 3 n Combined shared variables of algorithms 1 and 2. n Process Pi do { flag [i]: = true; turn = j; while (flag [j] and turn = j) ; critical section flag [i] = false; remainder section } while (1); n Meets all three requirements; solves the critical-section problem for two processes. Operating System Concepts 7. 24 Silberschatz, Galvin and Gagne 2002

Algorithm 3 n 结合算法 1和算法 2，是正确的算法 n turn=j; 描述可进入的进程（同时修改标志时） n 在进入区先修改后检查，并检查并发修改的先后： F 检查对方flag，如果不在临界区则自己进入－－空闲则入 F 否则再检查turn：保存的是较晚的一次赋值，则较晚的进程等待，较早的进程进入－－先到先入，后到等待 Operating System Concepts 7. 25 Silberschatz, Galvin and Gagne 2002

7. 2. 1. 3 Algorithm 3 n To prove “Mutual exclusion” property (That is Pi and Pj can’t be in CS at same time) F Pi enter CS only if flag[j]==false or turn==i F turn = 0 or 1, but cannot be both F… n To prove “Progress” property F Pi is in while statements only when flag[j]==true and turn==j F Then if Pj is not ready to enter CS, flag[j]==false F if Pj ready to enter CS, flag[j]==true, but turn=i or j , so Pi or Pj can enter n To prove “Bounded-waiting” property F If Pj exit its CS, flag[j]=false, then Pi can enter its CS Operating System Concepts 7. 26 Silberschatz, Galvin and Gagne 2002

Dekker算法 – 7. 4题 var boolean flag[2] ; flag[0]=flag[1]=false; int turn; turn=0/1; Pi: do { flag[i]=true; while flag[j] { if turn=j { flag[i]=false; while turn=j ; flag[i]=true; } Critical Section i 请证明：这个算法是否满足临界区 turn=j; 问题的三个条件 flag[i]=false; Remainder Section }while(1); Operating System Concepts 7. 27 Silberschatz, Galvin and Gagne 2002

7. 2. 2 Multiple-Process Solutions Bakery Algorithm (面包房算法) Algorithm of solving the Critical section for n processes n Before entering its critical section, process receives a number. Holder of the smallest number enters the critical section. 在进入临界区前，进程接收一个数字，最小数字的持有者进入临界区 n If processes Pi and Pj receive the same number, if i < j, then Pi is served first; else Pj is served first. n The numbering scheme always generates numbers in increasing order of enumeration; i. e. , 1, 2, 3, 3, 4, 5. . . Operating System Concepts 7. 28 Silberschatz, Galvin and Gagne 2002

Bakery Algorithm n Define the following Notation order : (a, b) -- (ticket #, process id #) F (a, b) < (c, d) if a < c or if a = c and b < d F max (a 0, …, an-1) is a number, k such that k ai for i = 0, …, n – 1 n Shared data boolean choosing[n]; int number[n]; Data structures are initialized to false and 0 respectively Operating System Concepts 7. 29 Silberschatz, Galvin and Gagne 2002

Fig 7. 5 The structure of process Pi in the Bakery Algorithm 取一个编号（在原有编号基础上+1） do { choosing[i] = true; number[i] = max(number[0], number[1], …, number [n – 1])+1; choosing[i] = false; Pj正在取编号 for (j = 0; j < n; j++) { while (choosing[ j]) ; while ((number[ j] != 0) &&((number[ j], j) < (number[i], i))) ; } 有j欲进入CS且Pj的编号<Pi , 或者Pi critical section 和Pj同时拿到相同编号但j<i number[i] = 0; remainder section 此时Pi拥有最小的number[i] } while (1); Operating System Concepts 7. 30 Silberschatz, Galvin and Gagne 2002

n 实现进程同步的方式 F Critical-section (软件方法) F Synchronization hardware (硬件方法) F Semaphores (信号量方法） Operating System Concepts 7. 31 Silberschatz, Galvin and Gagne 2002

7. 3 Synchronization Hardware 同步的硬件实现（硬件方法） n Hardware features can make the programming task easier and improve system efficiency. n Hardware instruction: Test and modify the content of a word atomically. boolean Test. And. Set(boolean &target) { boolean rv = target; target = true; return rv; } Operating System Concepts 7. 32 Silberschatz, Galvin and Gagne 2002

Mutual Exclusion with Test-and-Set n Shared data: boolean lock = false; n Process Pi do { while (Test. And. Set(lock)) ; critical section lock = false; remainder section }while(1); n 利用Test. And. Set实现进程互斥：每个临界资源设置一个公共布尔变量 lock，初值为FALSE n 在进入区利用TS进行检查：有进程在临界区时，重复检查；直到其它进程退出时，检查通过； Operating System Concepts 7. 33 Silberschatz, Galvin and Gagne 2002

The definition of Swap instruction n Atomically swap two variables. void Swap(boolean &a, boolean &b) { boolean temp = a; a = b; b = temp; } Operating System Concepts 7. 34 Silberschatz, Galvin and Gagne 2002

Mutual Exclusion with Swap n Shared data (initialized to false): boolean lock; /* (a global variable) n Process Pi do { key = true; /* ( a local variable) while (key == true) Swap(lock, key); critical section lock = false; remainder section } while (1); n Don’t satisfy the bounded-waiting requirement (when Pi, Pj execute “key=true” at same time) Operating System Concepts 7. 35 Silberschatz, Galvin and Gagne 2002

Fig 7. 10 Bounded-waiting mutual exclusion with Test. And. Set Boolean waiting[n], lock ; global variables, to be initialize to false Do { waiting[i] =false 意味着另一个进程从 waiting[i]=true; CS退出，并将Pi设置为可进入 key= true; while ( waiting[i] && key ) key=Test. And. Set(lock); waiting[i]=false; critical section; Key=false 意味着已经没有一个进程处于CS j= (i+1) % n ; while ((j != i) && !waiting[ j ]) j= (j+1) % n ; if (j == i) lock = false ; else waiting[ j ] = false ; remainder section ; 寻找下一个正在等待进入 CS的进程已经没有正在等待进入CS 的进程将Pj选为下一个可进入CS 的进程 }while(1) Operating System Concepts 7. 36 Silberschatz, Galvin and Gagne 2002

Bounded-waiting mutual exclusion with Test. And. Set n This algorithm satisfies all the critical section requirement. n To prove that the mutual-exclusion（互斥条件） requirement F Pi 可以进入CS只有在 waiting[i]== false 或 key == false时 F 只有在执行了 Test. And. Set后，key 才可能变为 false；而且只有第一个执行了 Test. And. Set 的进程，才能得到 key== false，其它进程必须等待 F 只有在一个进程离开CS时才会有一个（且最多仅有一个）进程的 waiting[i] 由true变为false F 从而确保满足互斥条件 Operating System Concepts 7. 37 Silberschatz, Galvin and Gagne 2002

Bounded-waiting mutual exclusion with Test. And. Set n To prove that the progress （有空让进条件） requirement (see p. 200) F 任何一个已经进入CS的进程在“exit section” 时，设置：lock =false 或 waiting[ j ]= false，确保了至少可以让一个进程进入CS n To prove that the bounded-waiting（有限等待条件） requirement (see p. 200) F 任何一个已经进入CS的进程Pi在“exit section” 时，将会依次扫描 waiting 数组（i+1, i+2, …n-1, 0, …i-1)，并仅将Pi后面最先找到的进程j的waiting[ j]设置为false F 这就使进程能依此循环进入CS Operating System Concepts 7. 38 Silberschatz, Galvin and Gagne 2002

n 硬件方法的优点 F 适用于任意数目的进程，在单处理器或多处理器上 F 简单，容易验证其正确性 F 可以支持进程内存在多个临界区，只需为每个临界区设立一个布尔变量 n 硬件方法的缺点 F 等待要耗费CPU时间，不能实现"让权等待" F 可能"饥饿"：从等待进程中随机选择一个进入临界区，有的进程可能一直选不上 F 可能死锁 Operating System Concepts 7. 39 Silberschatz, Galvin and Gagne 2002

7. 4 Semaphores信号量 --1965年由Dijkstra提出 n 软件和硬件方法解决互斥问题的缺陷: F 软件: 算法太复杂, 效率不高 F 中断屏蔽方法: 只能用于单机系统 F 硬件指令: 忙等待 n 1965年，荷兰学者Dijkstra提出的信号量机制是一种卓有成效的进程同步具。在长期广泛的应用中，信号量机制又得到了很大的发展，它从整型信号量机制发展到记录型信号量机制，进而发展为“信号集”机制。现在信号量机制已广泛应用于OS中。 n Synchronization tool that does not require busy waiting. 一种不需要忙等待的同步具. n Semaphore S – integer variable信号量S – 整型变量 n 解决N个进程的同步互斥问题 Operating System Concepts 7. 40 Silberschatz, Galvin and Gagne 2002

n 每个信号量s除一个整数值s. value（计数）外，还有一个进程等待队列s. L，其中是阻塞在该信号量的各个进程的标识 F 信号量只能通过初始化和两个标准的原语来访问－－作为 OS核心代码执行，不受进程调度的打断 F 初始化指定一个非负整数值，表示空闲资源总数（又称为" 资源信号量"）－－若为非负值表示当前的空闲资源数，若为负值其绝对值表示当前等待临界区的进程数 n “二值信号量(binary semaphore)"：只允许信号量取 0或 1值 Operating System Concepts 7. 41 Silberschatz, Galvin and Gagne 2002

7. 4. 1 整型信号量 n Semaphore S – integer variable信号量S – 整型变量 n can only be accessed via two indivisible (atomic) operations 仅能通过两个不可分割的[原子]操作访问 wait (S): ( P-操作 ) while S 0 do no-op; S--; signal (S): ( V-操作) S++; Operating System Concepts 7. 42 Silberschatz, Galvin and Gagne 2002

Fig 7. 11 Multual-exclusion with semaphores n Shared data: semaphore mutex; //initially mutex = 1 n Process Pi: do { wait(mutex); critical section signal(mutex); remainder section } while (1); Operating System Concepts 7. 43 Silberschatz, Galvin and Gagne 2002

7. 4. 2 记录型信号量 n To overcome the problem of “busy waiting” n Define a semaphore as a record typedef struct { int value; struct process *L; } semaphore; n Assume two simple operations: F block suspends the process that invokes it. F wakeup(P) resumes the execution of a blocked process P. Operating System Concepts 7. 44 Silberschatz, Galvin and Gagne 2002

Implementation n Semaphore operations now defined as wait(S) : S. value--; if (S. value < 0) { add this process to S. L; block; } signal(S) : S. value++; if (S. value <= 0) { remove a process P from S. L; wakeup(P); } n value 是负数，表示处于阻塞状态的进程数 Operating System Concepts 7. 45 Silberschatz, Galvin and Gagne 2002

wait、signal操作讨论 n 信号量的物理含义 S. value >0 表示有S个资源可用； S. value=0 表示无资源可用或表示不允许进程再进入临界区； S. value<0 则|S. value|表示在等待队列中进程的个数或表示等待进入临界区的进程个数。 wait(S)：表示申请一个资源；signal(S)表示释放一个资源。 Operating System Concepts 7. 46 Silberschatz, Galvin and Gagne 2002

wait、signal操作讨论 n wait、signal操作必须成对出现，有一个wait操作就一定有一个signal操作。当为互斥操作时，它们同处于同一进程。当为同步操作时，则不在同一进程中出现。 n 如果两个wait操作相邻，那么它们的顺序至关重要，而两个相邻的signal操作的顺序无关紧要。一个同步wait操作与一个互斥wait操作在一起时，同步wait操作在互斥wait 操作前。 n wait、signal操作的优缺点: 优点：简单，而且表达能力强（用wait、signal操作可解决任何同步互斥问题。）缺点：不够安全；wait、signal操作使用不当会出现死锁；实现复杂。 Operating System Concepts 7. 47 Silberschatz, Galvin and Gagne 2002

Semaphore as a General Synchronization Tool n Execute B in Pj only after A executed in Pi n Use semaphore flag initialized to 0 n Code: Pi Pj … … A wait(flag) signal(flag) B … Operating System Concepts … 7. 48 Silberschatz, Galvin and Gagne 2002

同步原语的不可分割性 n 含义: F 保证进程间互斥地使用同步原语 F 整体操作, 不可分割 n 实现方法: F 用软件的互斥算法, 用开关中断保证整体性 4不是好的解决方法 F 用硬件开关中断实现互斥和完整性 4仅适用于单处理机系统 F 用硬件指令方法在多处理机中实现互斥 F 用硬件和固件直接实现同步原语 Operating System Concepts 7. 49 Silberschatz, Galvin and Gagne 2002

同步原语的不可分割性 n 实例: 用硬件指令实现互斥使用的同步原语 Wait(S): While TS(lock) do skip; While S<=0 do skip; S: =S-1; lock : =false ; Signal(S): While TS(lock) do skip; S: =S+1 lock : =false ; Operating System Concepts 7. 50 /* 上锁 /* 同步原语代码 /* 开锁 Silberschatz, Galvin and Gagne 2002

利用信号量实现：进程互斥 n 为使多个进程能互斥地访问某临界资源，只需为该资源设置一个互斥信号量mutex, 并设其初值为 1，然后将各进程的临界区CS置于wait(mutex)和signal(mutex)操作之间即可。利用信号量实现共享打印机的A、B两进程互斥的类并行PASCAL程序描述如下： Operating System Concepts 7. 51 Silberschatz, Galvin and Gagne 2002

利用信号量实现进程互斥-1 var mutex: semaphore: =1 ； begin parbegin A: begin B: begin Input datd 1 from I/0 1 ； Input datd 2 from I/O 2 ； Compute……； wait(mutex) ； Print results 1 by printer; Print results 2 by printer; signal(mutex) ； end parend Operating System Concepts 7. 52 Silberschatz, Galvin and Gagne 2002

利用信号量实现：进程同步 n 利用信号量能解决进程间的同步问题，这里以下图所示的计算进程C和打印进程P通过缓冲区Buffer传送数据的同步问题为例说明。 C P Buffer Operating System Concepts 7. 53 Silberschatz, Galvin and Gagne 2002

利用信号量实现进程同步-1 C和P两进程基本算法如下： C：begin P: begin repeat Compute next number ; take from Buffer ; add to Buffer ; print last number ; until false end n C和P两进程并发执行，必须在执行序列上遵循以下规则，才能避免错误: F 只有当C进程把数据送入Buffer后，P进程才能从Buffer中取出数据来打印，否则P进程只能等待。 F 只有当P进程从Buffer中取走数据后，C进程才能将新计算的数据再存入Buffer, 否则C进程也只能等待。 Operating System Concepts 7. 54 Silberschatz, Galvin and Gagne 2002

利用信号量实现进程同步-2 n 为了实现进程同步，需采用同步信号量。 F 为了满足第一条同步规则，设置一个同步信号量full，它代表的资源是缓冲器满，它的初值为 0。 F 同样为了满足第二条同步规则，设置另一个同步信号量empty，它代表的资源是缓冲器空，它的初值为 1 。 n 实现C和P两进程同步的类PASCAL程序： Operating System Concepts 7. 55 Silberschatz, Galvin and Gagne 2002

var: empty, full: semaphore: =1, 0 ； begin parbegin C: begin repeat Compute next number ； wait(empty) ； Add to buffer ； siganl(full) ； until false end P: begin repeat wait(full) ； Take from Buffer ； signal(empty) ； Print last number ； until false end parend Operating System Concepts 7. 56 Silberschatz, Galvin and Gagne 2002

7. 4. 3 Deadlock and Starvation n Deadlock – two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes. 死锁 – 两个或多个进程无限期地等待一个事件的发生，而该事件正是由其中的一个等待进程引起的 n Let S and Q be two semaphores initialized to 1 S和Q是两个初值为 1的信号量 P 0 P 1 wait(S); wait(Q); wait(S); signal(Q); signal(Q) signal(S); Operating System Concepts 7. 57 Silberschatz, Galvin and Gagne 2002

Deadlock and Starvation n Starvation – indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended. 饥饿 – 无限期地阻塞。进程可能永远无法从它等待的信号量队列中移去 Operating System Concepts 7. 58 Silberschatz, Galvin and Gagne 2002

7. 4. 4 信号量集 n AND型信号量集 n 一段处理代码需要同时获取两个或多个临界资源――可能死锁：各进程分别获得部分临界资源，然后等待其余的临界资源，“各不相让” n 基本思想：在一个原语中，将一段代码同时需要的多个临界资源，要么全部分配给它，要么一个都不分配。称为Swait(Simultaneous Wait)。在Swait时，各个信号量的次序并不重要，虽然会影响进程归入哪个阻塞队列，但是由于是对资源全部分配或不分配，所以总有进程获得全部资源并在推进之后释放资源，因此不会死锁。 Operating System Concepts 7. 59 Silberschatz, Galvin and Gagne 2002

AND信号量 Swait(S 1, S 2, …, Sn) {while (TRUE) { if (S 1 >=1 && S 2 >= 1 && … && Sn >= 1) { for (i = 1; i <= n; ++i) --Si; break; } else {调用进程进入第一个小于1信号量的等待队列Sj. queue; 阻塞调用进程; } } } Operating System Concepts 7. 60 Silberschatz, Galvin and Gagne 2002

AND信号量 Ssignal(S 1, S 2, …, Sn) { for (i = 1; i <= n; ++i) { ++Si; for (each process P waiting in Si. queue) { 从等待队列Si. queue中取出进程P; if (判断进程P是否通过Swait中的测试) { 进程P进入就绪队列; } else { 进程P进入某等待队列；} } Operating System Concepts 7. 61 Silberschatz, Galvin and Gagne 2002

一般“信号量集” n 一次需要N个某类临界资源时，就要进行N次wait操作－－低效又可能死锁基本思想：在AND型信号量集的基础上进行扩充：进程对信号量Si 的测试值为ti（用于信号量的判断，即Si >= ti，表示资源数量低于ti时，便不予分配），占用值为di（用于信号量的增减，即Si = Si - di和Si = Si + di ） Swait(S 1, t 1, d 1; . . . ; Sn, tn, dn); Ssignal(S 1, d 1; . . . ; Sn, dn); 一般“信号量集”的几种特定情况： Swait(S, d, d)表示每次申请d个资源，当少于d个时，便不分配； Swait(S, 1, 1)表示互斥信号量； Swait(S, 1, 0)作为一个可控开关（当S 1时，允许多个进程进入临界区；当S=0时，禁止任何进程进入临界区）；一般“信号量集”未必成对使用Swait和Ssignal：如：一起申请，但不一起释放； Operating System Concepts 7. 62 Silberschatz, Galvin and Gagne 2002

7. 4. 5 Two Types of Semaphores n Counting semaphore – integer value can range over an unrestricted domain. 计数信号量(一般信号量) – 变化范围没有限制的整型值 n Binary semaphore – integer value can range only between 0 and 1; can be simpler to implement. 二值(二元)信号量 – 变化范围仅限于0和1的信号量； --容易通过硬件方式实现 Operating System Concepts 7. 63 Silberschatz, Galvin and Gagne 2002

Implementing S as a Binary Semaphore n A counting semaphore S can be implemented using binary semaphore. 计数信号量S可以用二值信号量实现 n Data structures: binary-semaphore S 1, S 2; int C: n Initialization: S 1 = 1 S 2 = 0 C = initial value of semaphore S Operating System Concepts 7. 64 Silberschatz, Galvin and Gagne 2002

Implementing S n wait operation wait(S 1); C--; if (C < 0) { signal(S 1); wait(S 2); } signal(S 1); n signal operation wait(S 1); C ++; if (C <= 0) signal(S 2); else signal(S 1); Operating System Concepts S>0：表示可用资源数目 S=0：既无可用资源也无进程等待 S<0：绝对值表示等待的进程数 7. 65 Silberschatz, Galvin and Gagne 2002

7. 5 Classical Problems of Synchronization 经典同步问题 n 7. 5. 1 Bounded-Buffer Problem 有限缓冲区问题（生产者消费者问题） n 7. 5. 2 Readers and Writers Problem 读者写者问题 n 7. 5. 3 Dining-Philosophers Problem 哲学家就餐问题 Operating System Concepts 7. 66 Silberschatz, Galvin and Gagne 2002

7. 5. 1 Bounded-Buffer Problem 有限缓冲区问题 n （producer-consumer Problem ）生产者-消费者问题 n 生产者-消费者问题是最著名的同步问题，它描述一组生产者（P 1 ……Pm）向一组消费者（C 1……Cq）提供消息。它们共享一个有界缓冲池（bounded buffer pool）, 生产者向其中投放消息，消费者从中取得消息，如下图所示。生产者-消费者问题是许多相互合作进程的一种抽象。 Operating System Concepts 7. 67 Silberschatz, Galvin and Gagne 2002

P 1 Pm C 1 Cq m B 0 B 1 …. …. . . ……… Bn-1 假定缓冲池中有n个缓冲区，每个缓冲区存放一个消息。由于缓冲池是临界资源，它只允许一个生产者投入消息，或者一个消费者从中取出消息。即生产者之间、生产者与消费者之间、消费者之间都必须互斥使用缓冲池。所以必须设置互斥信号量mutex，它代表缓冲池资源，它的数值为 1。 Operating System Concepts 7. 68 Silberschatz, Galvin and Gagne 2002

生产者和消费者二类进程P和C之间应满足下列二个同步条件： l 只有在缓冲池中至少有一个缓冲区已存入消息后，消费者才能从中提取消息，否则消费者必须等待。 l 只有缓冲池中至少有一个缓冲区是空时，生产者才能把消息放入缓冲区，否则生产者必须等待。为了满足第一个同步条件，设置一个同步信号量full，它代表的资源是缓冲区满，它的初始值为 0，它的值为n时整个缓冲池满。同样为了满足第二个同步条件，设置另一个同步信号量empty，它代表的资源是缓冲区空，它的初始值为n，表示缓冲池中所有缓冲区空。 Operating System Concepts 7. 69 Silberschatz, Galvin and Gagne 2002

Bounded-Buffer Problem 有限缓冲区问题 n Shared data Semaphore: full, empty, mutex; full – 满缓冲器的数量 empty – 空缓冲器的数量 mutex – 对缓冲器操作的互斥变量 Initially: full = 0, empty = n, mutex = 1 Operating System Concepts 7. 70 Silberschatz, Galvin and Gagne 2002

Fig 7. 12 The structure of Producer Process do { … produce an item in nextp … … add nextp to buffer … } while (1); Operating System Concepts 7. 71 Silberschatz, Galvin and Gagne 2002

Fig 7. 13 structure of the Consumer Process do { … remove an item from buffer to nextc … … consume the item in nextc … } while (1); Operating System Concepts 7. 72 Silberschatz, Galvin and Gagne 2002

Fig 7. 12 The structure of Producer Process do { … produce an item in nextp … wait(mutex); … add nextp to buffer … signal(mutex); } while (1); Operating System Concepts 7. 73 Silberschatz, Galvin and Gagne 2002

Fig 7. 13 structure of the Consumer Process do { wait(mutex); … remove an item from buffer to nextc … signal(mutex); … consume the item in nextc … } while (1); Operating System Concepts 7. 74 Silberschatz, Galvin and Gagne 2002

Fig 7. 12 The structure of Producer Process do { … produce an item in nextp … wait(empty); wait(mutex); … add nextp to buffer … signal(mutex); signal(full); } while (1); Operating System Concepts 7. 75 Silberschatz, Galvin and Gagne 2002

Fig 7. 13 structure of the Consumer Process do { wait(full); wait(mutex); … remove an item from buffer to nextc … signal(mutex); signal(empty); … consume the item in nextc … } while (1); Operating System Concepts 7. 76 Silberschatz, Galvin and Gagne 2002

7. 5. 2 The Readers-Writers Problem 读者写者问题 n 一个数据集（如文件）如果被几个并行进程所共享，有些进程只要求读数据集内容，它称读者(Reader)，而另一些进程则要求修改数据集内容，它称写者 (Writer)，几个读者可以同时读些数据集，而不需要互斥，但一个写者不能和其它进程（不管是写者或读者）同时访问些数据集，它们之间必须互斥。 n Shared data semaphore mutex, wrt; Initially mutex = 1, wrt = 1, readcount = 0 Operating System Concepts 7. 77 Silberschatz, Galvin and Gagne 2002

Fig 7. 14 The structure of a Writer Process 引人互斥信号量 wrt wait(wrt); … writing is performed … signal(wrt); Operating System Concepts 7. 78 Silberschatz, Galvin and Gagne 2002

Fig 7. 15 The structure of a Reader Process 第一个读者到时: wait(wrt); … reading is performed … 最后一个读者离开时: signal(wrt); Operating System Concepts 7. 79 Silberschatz, Galvin and Gagne 2002

Fig 7. 15 The structure of a Reader Process n 用readcount变量来记录读者数，读者程序为： readcount++; if (readcount == 1) wait(wrt); … reading is performed … readcount--; if (readcount == 0) signal(wrt); Operating System Concepts 7. 80 Silberschatz, Galvin and Gagne 2002

Fig 7. 15 The structure of a Reader Process n 由于readcount是读者间共享变量，属于临界资源，它也需互斥，为此又引人互斥信号量mutex: wait(mutex); /*确保互斥访问 readcount++; if (readcount == 1) /*第一个读者进入时 wait(wrt); 确保没有写者存在 signal(mutex); … reading is performed … wait(mutex); /*确保互斥访问 readcount--; if (readcount == 0) /*最后一个读者离开时 signal(wrt); 唤醒可能等待的写者 signal(mutex)； Operating System Concepts 7. 81 Silberschatz, Galvin and Gagne 2002

用一般信号集机制解读者-写者问题 n 采用一般"信号量集"机制：增加一个限制条件：同时读的"读者"最多RN个 F mx表示"允许写"，初值是 1 F L表示"允许读者数目"，初值为RN var RN integer ; L , mx : semaphore : =RN , 1 ; begin parbegin reader : begin repeat Swait (L , 1 ) ; Swait (mx , 1 , 0 ) ; perform read operation Ssignal (L , 1) ; until false ; end Operating System Concepts 7. 82 Silberschatz, Galvin and Gagne 2002

用一般信号集机制解读者-写者问题-1 writer: begin repeat Swait (mx , 1, 1, L , RN , 0 ); perform write operation Ssignal (mx , 1 ) ; until false ; parend end Operating System Concepts 7. 83 Silberschatz, Galvin and Gagne 2002

7. 5. 3 Dining-Philosophers Problem 哲学家就餐问题 n 问题描述：（由Dijkstra首先提出并解决） F 5个哲学家围绕一张圆桌而坐，桌子上放着5支筷子，每两个哲学家之间放一支； F 哲学家的动作包括思考和进餐； F 进餐时需要同时拿起他左边和右边的两支筷子；思考时则同时将两支筷子放回原处。 F 如何保证哲学家们的动作有序进行？如：不出现相邻者同时要求进餐；不出现有人永远拿不到筷子； Operating System Concepts 7. 84 Silberschatz, Galvin and Gagne 2002

Dining-Philosophers Problem n Shared data semaphore chopstick[5]; Initially all values are 1 Operating System Concepts 7. 85 Silberschatz, Galvin and Gagne 2002

Fig 7. 17 The structure of Philosophers i n Philosopher i: do { wait(chopstick[i]) wait(chopstick[(i+1) % 5]) … eat … signal(chopstick[i]); signal(chopstick[(i+1) % 5]); … think … } while (1); Operating System Concepts 7. 86 Silberschatz, Galvin and Gagne 2002

哲学家就餐问题讨论为防止死锁发生可采取的措施： n 最多允许 4个哲学家同时坐在桌子周围 n 仅当一个哲学家左右两边的筷子都可用时，才允许他拿筷子 n 给所有哲学家编号，奇数号的哲学家必须首先拿左边的筷子，偶数号的哲学家则反之 n 为了避免死锁，把哲学家分为三种状态，思考，饥饿，进食，并且一次拿到两只筷子，否则不拿 Operating System Concepts 7. 87 Silberschatz, Galvin and Gagne 2002

7. 6 Critical Regions 临界区 n 信号量存在的问题 F Signal和Wait 使用次序颠倒 signal(mutex) … critical section … wait(mutex) 当多个进程同时访问临界区时, 破坏了临界资源的互斥性 Operating System Concepts 7. 88 Silberschatz, Galvin and Gagne 2002

Critical Regions n 信号量存在的问题-1 F Wait 被换成Signal wait(mutex) … critical section … wait(mutex) Result: Deadlock will occur Operating System Concepts 7. 89 Silberschatz, Galvin and Gagne 2002

Critical Regions n 信号量存在的问题-2 F 缺少Wait或Signal F Result: 破坏互斥性或造成死锁 Operating System Concepts 7. 90 Silberschatz, Galvin and Gagne 2002

Critical Regions n High-level synchronization construct n A shared variable v of type T, is declared as: v: shared T n Variable v accessed only inside a region statement region v when B do S where B is a boolean expression. F It means “while statement S is being executed, no other process can access variable v. ” Operating System Concepts 7. 91 Silberschatz, Galvin and Gagne 2002

(conditional) Critical Regions n Regions referring to the same shared variable exclude each other in time. 访问区域相同共享变量同时互斥。 n When a process tries to execute the region statement, the Boolean expression B is evaluated. If B is true, statement S is executed. If it is false, the process is delayed until B becomes true and no other process is in the region associated with v. Operating System Concepts 7. 92 Silberschatz, Galvin and Gagne 2002

(conditional) Critical Regions n If two statements are executed concurrently in two processes: region v when (true) S 1 region v when (true) S 2 The result will be executed sequentially as “S 1 followed by S 2” or “S 2 followed by S 1” Operating System Concepts 7. 93 Silberschatz, Galvin and Gagne 2002

Example – Bounded Buffer n Critical-region construct 可以有效地解决一般的同步问题。 n 例如：生产者-消费者问题： F Shared data: struct buffer { int pool[n]; int count, in, out; } Operating System Concepts 7. 94 Silberschatz, Galvin and Gagne 2002

Bounded Buffer Producer Process n Producer process inserts nextp into the shared buffer region buffer when( count < n) { pool[in] = nextp; in: = (in+1) % n; count++; } Operating System Concepts 7. 95 Silberschatz, Galvin and Gagne 2002

Bounded Buffer Consumer Process n Consumer process removes an item from the shared buffer and puts it in nextc region buffer when (count > 0) { nextc = pool[out]; out = (out+1) % n; count--; } Operating System Concepts 7. 96 Silberschatz, Galvin and Gagne 2002

Implementation region x when B do S (自学） n The conditional critical region could be implemented by a compiler. n Associate with the shared variable x, the following variables: semaphore mutex, first-delay, second-delay; int first-count, second-count; n Mutually exclusive access to the critical section is provided by mutex提供互斥访问临界区。 n If a process cannot enter the critical section because the Boolean expression B is false, it initially waits on the first-delay semaphore; moved to the second-delay semaphore before it is allowed to reevaluate B. 如果因为布尔表达式 B 是false，进程不能进入临界区，它开始等待first-delay信号量; 在它被允许再计算B以前，改到second-delay信号量。 Operating System Concepts Silberschatz, Galvin and Gagne 2002 7. 97

$Implementation region x when B do S (Cont. ) wait(mutex); while(!B) { first_count++; if$

Implementation region x when B do S (Cont. ) wait(mutex); while(!B) { first_count++; if (second_count>0) signal(second_delay); else signal(mutex); wait(first_delay); first_count--; second_count++; if (first_count>0) signal(first_delay); else signal(second_delay); wait(second_delay); second_count--; } S; Operating System Concepts 7. 98 Silberschatz, Galvin and Gagne 2002

Implementation region x when B do S (Cont. ) If (first_count>0) signal(first_delay); else if (second_count>0) signal(second_delay); else signal(mutex); Operating System Concepts 7. 99 Silberschatz, Galvin and Gagne 2002

Implementation n Keep track of the number of processes waiting on first-delay and second-delay, with first-count and second-count respectively. 记录等待first-delay and second-delay的进程数与first-count and second-count分别地。 n The algorithm assumes a FIFO ordering in the queuing of processes for a semaphore. 算法假定信号量进程队列为一个FIFO n For an arbitrary queuing discipline, a more complicated implementation is required. 为任意队列要求，需要更复杂的实现 Operating System Concepts 7. 100 Silberschatz, Galvin and Gagne 2002

7. 7 Monitors管程 n用信号量可实现进程间的同步，但由于信号量的控制分布在整个程序中，其正确性分析很困难。 n管程是管理进程间同步的机制，它保证进程互斥地访问共享变量，并方便地阻塞和唤醒进程。 n管程可以函数库的形式实现。相比之下，管程比信号量好控制。 Operating System Concepts 7. 101 Silberschatz, Galvin and Gagne 2002

1. 信号量同步的缺点 n 同步操作分散：信号量机制中，同步操作分散在各个进程中，使用不当就可能导致各进程死锁（如wait、 signal操作的次序错误、重复或遗漏） n 易读性差：要了解对于一组共享变量及信号量的操作是否正确，必须通读整个系统或者并发程序； n 不利于修改和维护：各模块的独立性差，任一组变量或一段代码的修改都可能影响全局； n 正确性难以保证：操作系统或并发程序通常很大，很难保证这样一个复杂的系统没有逻辑错误； Operating System Concepts 7. 102 Silberschatz, Galvin and Gagne 2002

2. 管程的引入 n 最早由Dijkstra提出, 1974年，Hoare和Hanson所实现；其基本思想是把信号量及其操作原语封装在一个对象内部。即：将共享变量以及对共享变量能够进行的所有操作集中在一个模块中。 n 管程的定义：管程是关于共享资源的数据结构及一组针对该资源的操作过程所构成的软件模块。 n 管程可增强模块的独立性：系统按资源管理的观点分解成若干模块，用数据表示抽象系统资源，同时分析了共享资源和专用资源在管理上的差别，按不同的管理方式定义模块的类型和结构，使同步操作相对集中，从而增加了模块的相对独立性 n 引入管程可提高代码的可读性，便于修改和维护，正确性易于保证：采用集中式同步机制。一个操作系统或并发程序由若干个这样的模块所构成，一个模块通常较短，模块之间关系清晰。 Operating System Concepts 7. 103 Silberschatz, Galvin and Gagne 2002

n High-level synchronization construct that allows the safe sharing of an abstract data type among concurrent processes. 高级的同步机构允许并发进程间一种抽象的数据类型安全共享。 n A monitor is characterized by a set of programmingdefined operators 一个管程表示一个编程定义操作的集合 n The monitor construct ensures that only one process at a time can be active within monitor. 管程结构保证在某一时刻仅仅一个进程运行在管程里。 Operating System Concepts 7. 104 Silberschatz, Galvin and Gagne 2002

3. 管程的主要特性 n 模块化：一个管程是一个基本程序单位，可以单独编译； n 抽象数据类型：管程是一种特殊的数据类型，其中不仅有数据，而且有对数据进行操作的代码 n 信息封装：管程是半透明的，管程中的外部过程（函数）实现了某些功能，至于这些功能是怎样实现的，在其外部则是不可见的； Operating System Concepts 7. 105 Silberschatz, Galvin and Gagne 2002

4. 管程的实现要素 n 管程中的共享变量在管程外部是不可见的，外部只能通过调用管程中所说明的外部过程（函数）来间接地访问管程中的共享变量； n 为了保证管程共享变量的数据完整性，规定管程互斥进入； n 管程通常是用来管理资源的，因而在管程中应当设有进程等待队列以及相应的等待及唤醒操作； Operating System Concepts 7. 106 Silberschatz, Galvin and Gagne 2002

5. 管程中的多个进程进入 n 当一个进入管程的进程执行等待操作时，它应当释放管程的互斥权；当一个进入管程的进程执行唤醒操作时（如Ｐ唤醒Ｑ），管程中便存在两个同时处于活动状态的进程。 n 管程中的唤醒切换方法： F P等待Q继续，直到Q等待或退出； F Q等待P继续，直到P等待或退出； F 规定唤醒为管程中最后一个可执行的操作； Operating System Concepts 7. 107 Silberschatz, Galvin and Gagne 2002

n 入口等待队列：因为管程是互斥进入的，所以当一个进程试图进入一个巳被占用的管程时它应当在管程的入口处等待，因而在管程的入口处应当有一个进程等待队列，称作入口等待队列。 n 紧急等待队列：如果进程Ｐ唤醒进程Ｑ，则Ｐ等待Ｑ继续，如果进程Ｑ在执行又唤醒进程Ｒ，则Ｑ等待Ｒ继续，. . . ，如此，在管程内部，由于执行唤醒操作，可能会出现多个等待进程（已被唤醒，但由于管程的互斥进入而等待），因而还需要有一个进程等待队列，这个等待队列被称为紧急等待队列。它的优先级应当高于入口等待队列的优先级。 Operating System Concepts 7. 108 Silberschatz, Galvin and Gagne 2002

6. 条件变量(condition) n 由于管程通常是用于管理资源的，因而在管程内部，应当存在某种等待机制。当进入管程的进程因资源被占用等原因不能继续运行时使其等待。为此在管程内部可以说明和使用一种特殊类型的变量----条件变量。每个表示一种等待原因，并不取具体数值－－相当于每个原因对应一个队列。 Operating System Concepts 7. 109 Silberschatz, Galvin and Gagne 2002

Fig 7. 21 Monitor With Condition Variables Operating System Concepts 7. 110 Silberschatz, Galvin and Gagne 2002

n 同步操作原语wait和signal：针对条件变量x，x. wait()将自己阻塞在x队列中，x. signal()将x队列中的一个进程唤醒。 F x. wait()：如果紧急等待队列非空，则唤醒第一个等待者；否则释放管程的互斥权，执行此操作的进程排入x队列尾部（紧急等待队列与x队列的关系：紧急等待队列是由于管程的互斥进入而等待的队列，而x队列是因资源被占用而等待的队列） F X. signal()：如果x队列为空，则相当于空操作，执行此操作的进程继续；否则唤醒第一个等待者，执行此操作的进程排入紧急等待队列的尾部 n 若进程P唤醒进程Q，则随后可有两种执行方式（进程P、Q都是管程中的进程） F P等待，直到执行Q离开管程或下一次等待。Hoare采用。 F Q送入Ready队列，直到执行P离开管程或下一次等待。1980年， Lampson和Redell采用。 Operating System Concepts 7. 111 Silberschatz, Galvin and Gagne 2002

7. 管程的的组成 n 名称：为每个共享资源设立一个管程 n 数据结构说明：一组局部于管程的控制变量 n 操作原语：对控制变量和临界资源进行操作的一组原语过程（程序代码），是访问该管程的唯一途径。这些原语本身是互斥的，任一时刻只允许一个进程去调用，其余需要访问的进程就等待。 n 初始化代码：对控制变量进行初始化的代码 Operating System Concepts 7. 112 Silberschatz, Galvin and Gagne 2002

The syntax of a monitor管程的语法 n monitor-name { shared variable declarations procedure body P 1 (…) {. . . } procedure body P 2 (…) {. . . } procedure body Pn (…) {. . . } { initialization code } } Operating System Concepts 7. 113 Silberschatz, Galvin and Gagne 2002

Fig 7. 20 Schematic View of a Monitor Operating System Concepts 7. 114 Silberschatz, Galvin and Gagne 2002

8. 管程和进程的异同点 n 设置进程和管程的目的不同 n 系统管理数据结构 F 进程：PCB F 管程：等待队列 n 管程被进程调用 n 管程是操作系统的固有成分，无创建和撤消 Operating System Concepts 7. 115 Silberschatz, Galvin and Gagne 2002

Monitors (Cont. -1) n To allow a process to wait within the monitor, a condition variable must be declared, as 允许一个进程在管程里等待（阻塞），一个条件变量必须被声明 condition x, y; n Condition variable can only be used with the operations wait and signal. 条件变量只能使用wait 和 signal 操作 Operating System Concepts 7. 116 Silberschatz, Galvin and Gagne 2002

Monitors (Cont. -2) F The operation x. wait() means that the process invoking this operation is suspended until another process invokes x. signal(); x. wait ()操作表示调用这操作的进程挂起在条件x上，直到另外的进程调用 x. signal () F The x. signal operation resumes exactly one suspended process. If no process is suspended, then the signal operation has no effect. x. signal()操作恢复（唤醒）在条件x上被挂起进程。如果没有进程被挂起，那么signal操作没有效果。[注意: 与信号量的区别] Operating System Concepts 7. 117 Silberschatz, Galvin and Gagne 2002

Fig 7. 20 Schematic View of a Monitor Operating System Concepts 7. 118 Silberschatz, Galvin and Gagne 2002

Fig 7. 21 Monitor With Condition Variables Operating System Concepts 7. 119 Silberschatz, Galvin and Gagne 2002

Structure of Monitor Monitior Waiting Area Queue of Entering Processes Entrance M 0 NITOR Local Data Condition c 1 Condition Variables C 1. wait. . . Procedure 1 . . . condition cn Procedure k Cn. wait Urgent Queue Initialization Code Cx. signal Operating System Concepts Exit 7. 120 Silberschatz, Galvin and Gagne 2002

Monitors (Cont. -2) n When the x. signal() operation is invoked by process P, there is a suspended process Q associated with condition X. Two possibilities exist: 当 x. signal () 操作被进程 P 调用, 有一个与条件便变量 X相关的被挂进程Q 。存在二个可能性： 1. P either waits until Q leaves the monitor, or waits for another condition. P等待直到 Q 离开管程，或等另外的条件。 2. Q either waits until P leaves the monitor, or waits for another condition. Q等待直到 P 离开管程，或等另外的条件。 Operating System Concepts 7. 121 Silberschatz, Galvin and Gagne 2002

Example of Monitor n A monitor solution to the Dining- Philosophers Operating System Concepts 7. 122 Silberschatz, Galvin and Gagne 2002

Fig 7. 22 A monitor solution to the Dining- Philosophers monitor dp { enum {thinking, hungry, eating} state[5]; //每个哲学家都处在“thinking, hungry, eating”三种状态之一 condition self[5]; void pickup(int i) // following slides void putdown(int i) // following slides void test(int i) // following slides void init() { for (int i = 0; i < 5; i++) state[i] = thinking; } } Operating System Concepts 7. 123 Silberschatz, Galvin and Gagne 2002

Fig 7. 22 A monitor solution to the Dining. Philosophers (Cont. ) void pickup(int i) { state[i] = hungry; test[i]; if (state[i] != eating) self[i]. wait(); } void putdown(int i) { state[i] = thinking; // test left and right neighbors test((i+4) % 5); //唤醒可能在self[i+4]上阻塞的进程 test((i+1) % 5); //唤醒可能在self[i+1]上阻塞的进程 } Operating System Concepts 7. 124 Silberschatz, Galvin and Gagne 2002

Fig 7. 22 A monitor solution to the Dining. Philosophers (Cont. -1) void test(int i) { if ( (state[(i + 4) % 5] != eating) && (state[i] == hungry) && (state[(i + 1) % 5] != eating)) { state[i] = eating; self[i]. signal(); } } Operating System Concepts 7. 125 Silberschatz, Galvin and Gagne 2002

Fig 7. 22 A monitor solution to the Dining. Philosophers (Cont. -2) n Philosopher[i]: Do{ dp. pickup(i); eat dp. putdown(i); think }while(1) n 确保: F No deadlock will occur F It’s possible for a philosopher to starve to death Operating System Concepts 7. 126 Silberschatz, Galvin and Gagne 2002

Monitor Implementation Using Semaphores[*] n Variables semaphore mutex; // (initially = 1) semaphore next; // (initially = 0) int next-count = 0; n Each external procedure F will be replaced by wait(mutex); … body of F; … if (next-count > 0) signal(next) else signal(mutex); n Mutual exclusion within a monitor is ensured. Operating System Concepts 7. 127 Silberschatz, Galvin and Gagne 2002

Monitor Implementation [*] n For each condition variable x, we have: semaphore x-sem; // (initially = 0) int x-count = 0; n The operation x. wait can be implemented as: x-count++; if (next-count > 0) signal(next); else signal(mutex); wait(x-sem); x-count--; Operating System Concepts 7. 128 Silberschatz, Galvin and Gagne 2002

Monitor Implementation n The operation x. signal can be implemented as: if (x-count > 0) { next-count++; signal(x-sem); wait(next); next-count--; } Operating System Concepts 7. 129 Silberschatz, Galvin and Gagne 2002

Monitor Implementation n Conditional-wait construct: x. wait(c); F c – integer expression that is evaluated when the wait operation is executed. F value of c (a priority number) stored with the name of the process that is suspended. F when x. signal is executed, process with smallest associated priority number is resumed next. Operating System Concepts 7. 130 Silberschatz, Galvin and Gagne 2002

Monitor Implementation(cont. ) n Check two conditions to establish correctness of system: 系统建立正确性要检查 2 个条件： F User processes must always make their calls on the monitor in a correct sequence. 用户进程必须正确的顺序调用管程。 F Must ensure that an uncooperative process does not ignore the mutual-exclusion gateway provided by the monitor, and try to access the shared resource directly, without using the access protocols. 必须保证不同步进程不忽略管程提供了的互斥网关，并且试图直接存取共享资源, 没有使用存取协议。 Operating System Concepts 7. 131 Silberschatz, Galvin and Gagne 2002

7. 8 OS Synchronization 操作系统的同步机制 7. 8. 1 Synchronization in Solaris 2 n Implements a variety of locks to support multitasking, multithreading (including real-time threads), and multiprocessing. 实现各种锁支持多任务、多线程(包括实时线程)、和多进程 n Uses adaptive mutexes for efficiency when protecting data from short code segments. 当保护数据短代码段时，为了效率使用可变互斥量 n Uses condition variables and readers-writers locks when longer sections of code need access to data. 当代码的更长部分需要访问到数据时，使用条件变量和读者-写者锁 n Uses turnstiles to order the list of threads waiting to acquire either an adaptive mutex or reader-writer lock. 使用 turnstiles(十字转门, 栅门) 排列等待需要适应互斥或读者-写者锁的线程列表 Operating System Concepts 7. 132 Silberschatz, Galvin and Gagne 2002

7. 8. 2 Windows 2000 Synchronization n Uses interrupt masks to protect access to global resources on uniprocessor systems. 在单处理机系统上使用中断屏蔽保护存取全局资源 n Uses spinlocks(自旋锁) on multiprocessor systems. 在多处理机系统上使用自旋锁。 F 利用busy waiting 而非blocking来阻止进程前进； F CPU不会去做其他事情，虽然浪费了部分CPU时间，但省去了进程切换； F 适合短代码的加锁: wait(S): S--; while S<0 do{}; signal(S): S++; F 与spin lock相对应的就是suspend lock（挂起锁），即一般的锁，会挂起（阻塞）进程的执行 Operating System Concepts 7. 133 Silberschatz, Galvin and Gagne 2002

Windows 2000 Synchronization (cont. ) n Provides dispatcher objects for thread synchronization outside of the kernel. 为内核外线程同步提供调度器对象。 n Using a dispatcher objects, a thread can synchronize according to several different mechanisms include mutexes 、semaphores and event. An event acts much like a condition variable. 使用一个调度器对象, 一个线程能根据不同的同步机制, 包括互斥、信号量和事件等。一个事件类似一个条件变量。 n Dispatcher objects may be in either a signaled or nonsignaled state. 调度器对象可以在任何一个signaled可用或 nonsignaled不可用状态。 Operating System Concepts 7. 134 Silberschatz, Galvin and Gagne 2002

Windows 2000/XP的进程互斥和同步 n在Windows 2000/XP中提供了互斥对象、信号量对象和事件对象等三种同步对象和相应的系统调用，用于进程和线程同步。从本质上讲，这组同步对象的功能是相同的，它们的区别在于适用场合和效率会有所不同。 n对象名称是由用户给出的字符串。不同进程中用同样的名称来创建或打开对象，从而获得该对象在本进程的句柄。 n对象状态可分成可用和不可用两种。对象可用(signaled state)表示该对象不被任何线程使用或所有；而对象不可用 (nonsignaled state)表示该对象被某线程使用。返回 Operating System Concepts 7. 135 Silberschatz, Galvin and Gagne 2002

Windows 2000/XP的进程互斥和同步-1 n 互斥对象(Mutex)相当于互斥信号量，在一个时刻只能被一 n n 个线程使用。信号量对象(Semaphore)是资源信号量，它的取值在 0到指定最大值之间，用于限制并发访问的线程数。事件对象(Event)相当于“触发器”，可通知一个或多个线程某事件的出现。临界区对象(Critical Section)只能用于在同一进程内使用的临界区，同一进程内各线程对它的访问是互斥进行的。互锁变量访问是最基本的互斥手段，其他的互斥和共享机制都是以它为基础的。它相当于硬件TS指令。用于对整型变量的操作，可避免线程间切换对操作连续性的影响。 Operating System Concepts 7. 136 Silberschatz, Galvin and Gagne 2002

7. 9 Atomic Transactions[*] 原子事务处理 To use database-systems techniques in operating system 7. 9. 1 System Model 系统模型 n A collection of instructions (or operations) that performs a single logical function is called a transaction(事务). n A major issue in processing transactions is the preservation of atomicity(保护原子性) despite the possibility of failures within the computer system. n A transaction is simply a sequence of read and write operation, terminated by either a commit operation or an abort operation. n The state of the data accessed by an aborted transaction must be restored to what it just before the started executing. Such a transaction has been rolled back回退. Operating System Concepts 7. 137 Silberschatz, Galvin and Gagne 2002

Atomic Transactions (cont. ) n We are concerned with ensuring transaction atomicity in an environment where failure result in loss of information on volatile storage (nonvolatile storage , stable storage). 7. 9. 2 Log-Based Recovery 基于日志的恢复 n One way to ensure atomicity is to record , on stable storage, information describing all the modifications made by the transactions to the various data it accessed. The most widely used method for achieving this form of recording is write-ahead logging (预写日志纪录) 。 n The system maintains , on stable storage , a data structure called the log(日志). Each log record describes a single operation of a transaction write , and has the following fields: Transaction Name , Data Item Name , Old Value and New Value. Operating System Concepts 7. 138 Silberschatz, Galvin and Gagne 2002

Atomic Transactions (cont. ) n Using the log , the system can handle any failure that does not result in the loss of information on nonvolatile storage. The recovery algorithm uses two procedures: undo(Ti) and redo(Ti). 7. 9. 3 Checkpoint 检查点 n To reduce these types of overhead : most of the transactions need to be redone have already actually updated the data that the log says they need to modify, we introduce the concept of checkpoint. During execution , the system maintain the write-ahead log and periodically performs checkpoint. n 7. 9. 4 Concurrent Atomic Transactions 并行的原子事务处理 Operating System Concepts 7. 139 Silberschatz, Galvin and Gagne 2002

Ex. 7. 4 Dekker算法 7. 4 第一个公认的解决两进程（线程）临界区问题的算法是由Dekker提出的，故称为Dekker算法。算法如下所示。说明该算法满足临界区问题的三个必要条件。共享变量： int turn, 初值为 0； Boolean flag[2]，初值均为false; Pi(i=0, 1) Operating System Concepts 7. 140 Silberschatz, Galvin and Gagne 2002

Ex. 7. 4 Dekker算法(2) while(1) { 1. 互斥(mutual exclusion) flag[ i ] = true; A) Pi和Pj不可能同时进入CS： while (flag[j]) { turn==j 和turn==I不会同时满足 if (turn==j) { flag[ i ] = false; B)一个进程(如Pi)先进入CS, 则flag[ i ]为 true, 则Pj无法进入 while ( turn == j ); 2. 前进(progress） flag[ i ] = true; A)Pi申请进入，Pj不想进入，则flag[ i ]==false, Pi顺利进入 } } B)Pi和Pj都想进入，则turn==j时Pj进入， turn==i时Pi进入 CS 3. 有限等待(bounded waiting) turn = j; Pi离开CS后，置turn=j, flag[ i ]=false, 这时Pj可以进入，如果Pj没有进入，Pi又执行了falg[ i ]=true, 则由于turn==j，所以Pi无法进入，而Pj可以进入 flag[ i ] = false; RS } Operating System Concepts 7. 141 Silberschatz, Galvin and Gagne 2002

Ex. 7. 5 Eisenberg and Mc. Guire’s algorithm 7. 5 第一个公认的n进程临界区问题的解决方法是由 Eisenberg和Mc. Guire提出的。该算法中，n个进程共享下面的变量： enum pstate { idle, want_in, in_cs }; pstate flag[n]; int turn; 算法描述如下页证明该算法满足临界区问题的所有要求。 Operating System Concepts 7. 142 Silberschatz, Galvin and Gagne 2002

Ex. 7. 5 Eisenberg and Mc. Guire’s algorithm(2) 1. 互斥(mutual exclusion) While(1) { A) 两个进程Px和Py不可能同时进入CS： while(1) { flag[i] = want_in; j = turn; while (j !=i) { if (flag[j]!=idle) j = turn } flag[i] =in_cs; j = 0; while ((j<n)&&(j ==i || flag[j]!=in_cs) j ++ ; if ((j>=n)&&(turn==i||flag[turn]==idle)) break; } j = (turn+1)%n; while(flag[j]==idle) j=(j+1)%n; } Operating System Concepts A)Px申请进入，其他进程不想进入，则其他进程flag均为idle, 则Px的j>=n成立，if条件成立，跳出while，进入CS B)若干进程想进入，如Pturn也想进入，则 Pturn优先进入；否则，编号在turn后的最小号的想进入的进程进入CS 3. 有限等待(bounded waiting) CS turn=j; flag[i]=idle; B)一个进程(如Px)先进入CS, 则turn==x， flag[turn]==in_cs, 则其他进程无法进入 2. 前进(progress） else j = (j+1)%n; turn = i ; turn==x 和turn==y不会同时满足，故Px和Py 的两个if 条件不会都满足 RS Pi离开CS时，置turn为想进入的进程中大于 turn的最小欲进入之进程号，该进程就进入。进程Pk不会饿死，最多等待（k-turn)个进程的 CS执行 Silberschatz, Galvin and Gagne 2002 7. 143

Ex. 7. 8 理发问题：一个理发店内有一张沙发，可以坐n个等待理发的顾客，理发室内有一张理发椅。当没有顾客时，理发师就休息；当一个新顾客进来时，如果所有的座位上都有人，他就离开理发店；如果沙发上有空位，他就坐下；如果理发师在休息，顾客就唤醒他让他为其理发。试用信号量来同步理发师和顾客的行为。 Operating System Concepts 7. 144 Silberschatz, Galvin and Gagne 2002

Ex. 7. 8 理发问题(2) Semaphore max; //初始n+1, 表示理发店可以容纳总人数 Semaphore chair; //初始n，空闲的椅子 Semaphore barber; //初始1，表示理发椅空闲 Semaphore finished; //初始0，表示一次理发结束 Semaphore ready; //初始0，表示客人准备就绪 Customer: While(1){ wait(max); wait(chair); wait(barber); signal(chair); signal(ready); … barbered … wait(finished); signal(max); } Barber: While(1){ wait(ready); … barbering… signal(finished); signal(barber); } Operating System Concepts 7. 145 Silberschatz, Galvin and Gagne 2002

Ex. 7. 9抽烟问题：有一个烟草代理和三个抽烟者。抽烟者若要抽烟，必须具有烟叶、烟纸和火柴。三个抽烟者中，一人缺烟叶、一人缺烟纸、一人缺火柴。烟草代理会源源不断地分别供应烟叶、烟纸和火柴，并将他们放在桌上。如果他放的是烟叶，则缺烟叶的抽烟者拾起烟叶，制作香烟，然后抽烟；其他类推。试用信号量同步烟草代理和三个抽烟者。 Operating System Concepts 7. 146 Silberschatz, Galvin and Gagne 2002

Ex. 7. 9抽烟问题(2) Semaphore smoker[3]; Semaphore material[3]; Semaphore agent; Int turn; //初始0，三个抽烟者 //初始0，三种原料 //初始1，供应商 //初始0，轮到谁 Agent: While(1){ wait(agent); signal(smoker[turn]); signal(material[(turn+1)%3]); signal(material[(turn+2)%3]); turn= (turn+1)%3; } Operating System Concepts Smoker-i: While(1){ wait(smoker[i]); wait(material[(i+1)%3]); wait(material[(i+2)%3]); signal(agent); 7. 147 } Silberschatz, Galvin and Gagne 2002

Ex. 7. 11 写一个管程（monitor）用于实现有限缓冲区的生产者－消费者问题，要求将有限缓冲区置于管程内。 Operating System Concepts 7. 148 Silberschatz, Galvin and Gagne 2002

$Ex. 7. 11(2) Producer process: While(1) { produce an item; bounded_buffer. put_item(); } Monitor$

Ex. 7. 11(2) Producer process: While(1) { produce an item; bounded_buffer. put_item(); } Monitor bounded_buffer { item pool[n]; int count, in, out; condition full, empty; void get_item() { if (count==0) full. wait(); get_from_buffer(); count--; empty. signal(); } void put_item() { if (count==n) empty. wait(); put_to_buffer(); count++; full. signal(); } void init() { count=in=out=0; } Consumer process: While (1) { bounded_buffer. get_item(); consume the item; } } Operating System Concepts 7. 149 Silberschatz, Galvin and Gagne 2002

2003年硕士研究生入学考试试题 2 4. 关于临界区问题（critical section problem）的一个算法（假设只有进程P 0和P 1可能会进入该临界区）如下（i为 0或 1），该算法。 A、不能保证进程互斥进入临界区，且会出现“饥饿”（ Starvation) B、不能保证进程互斥进入临界区，但不会出现“饥饿” C、保证进程互斥进入临界区，但会出现“饥饿” D、保证进程互斥进入临界区，不会出现“饥饿” repeat retry：if (turn -1 ) turn : = i； if (turn i ) go to retry； turn : = -1； Critical Section（临界区） turn : = 0； remainder Section（其它区域） until false；答：A Operating System Concepts 7. 150 Silberschatz, Galvin and Gagne 2002

2000年硕士研究生入学考试试题 2 (10分) 下述关于双进程临界区问题的算法（对编号为id的进程）是否正确： do{ blocked[id]=true; while(turn !=id)of { while(blocked[1 -id]); 若此时进程切换，且让对方再次进入临 turn=id; 界区，互斥条件无法满足 } <编号为id的进程的临界区 CS> blocked[id]=false; 编号为id的进程的非临界区 } while (true)：其中，布尔型数组blocked[2]初始值为为{false, false}，整型turn初始值为 0， id代表进程编号（0或 1）。请说明它的正确性，或指出错误所在。 Operating System Concepts 7. 151 Silberschatz, Galvin and Gagne 2002

2000年硕士研究生入学考试试题 3 (10分) 信号量如果只能取 0或 1为值，就变成了二元信号量。二元信号量更容易实现。而且，信号量可以由二元信号量替换。以下所列函数试图用二元信号量操作wait. B()和signal. B()替换信号量wait()、signal()： …… 其中，用于互斥的二元信号量mutex初始化为 1，用于进程挂起的二元信号量delay初始化为 0。请指出该替换算法的错误所在。 Operating System Concepts 7. 152 Silberschatz, Galvin and Gagne 2002

2000年硕士研究生入学考试试题 3 (2) wait(semaphore s) { wait. B(mutex); s = s-1; if (s<0) { signal. B(mutex); wait. B(delay); } else signal. B(mutex); } Operating System Concepts signal(semaphore s) { wait. B(mutex); s= s+1; if(s<=0) signal. B(delay); signal. B(mutex); } 1、s = 0 时，p 1 calls wait() and p 2 calls wait()并都在执行wait. B(delay)前交出CPU 2、p 3 and p 4 call signal()。此时本应允许p 1 and p 2 wakeup，但因delay升至 1后无法再升，导致p 1 or p 2 中一个仍在wait(delay) 7. 153 Silberschatz, Galvin and Gagne 2002

1997年硕士研究生入学考试试题 4 下述流程是解决两进程互斥访问临界区问题的一种方法。试从“互斥”（mutual exclusion）、"空闲让进"（progress）、"有限等待"(bounded waiting)三方面讨论它的正确性。如果它是正确的，则证明之；如果它不正确，请说明理由。 program attemp; var c 1，c 2 ：integer； procedure p 1（*第一个进程p 1*） begin repeat Remain Section 1； repeat c 1=1 -c 2； until c 2<>0 Critical Section；(*临界区*) C 1=1； Until false End Operating System Concepts Silberschatz, Galvin and Gagne 2002 7. 154

1997年硕士研究生入学考试试题 4 (2) Procedure p 2　（*另一个进程p 2*） begin repeat Remain Section 2； Repeat c 2=1 -c 1； Until c 1<>0 Critical Section ；(*临界区*) c 2=1； until false end begin（*主程序*） c 1=1； c 2=1； cobegin p 1； p 2；（*二进程p 1, p 2开始*） coend Operating System Concepts 7. 155 Silberschatz, Galvin and Gagne 2002

2005年硕士研究生入学考试试题 2 （10分）试就Mutual Exclusion、 Progress、Bounded Waiting 论述以下解决双进程临界区问题的算法是错误的： Process P 0: do { flag[0] =true; while (flag[1]); critical section flag[0] =false; remainder section } while (1); Process P 1: do { flag[1] =true; while (flag[0]); critical section flag[1] =false; remainder section } while (1); Operating System Concepts 7. 156 Silberschatz, Galvin and Gagne 2002

2005年硕士研究生入学考试试题 2 （2） n 答案： F Mutual Exclusion （3分） 4 满足 F Progress （4分） 4 不满足 4 反例：当P 0对flag[0]赋值，紧接着，马上执行P 1对 flag[1]的赋值。于是，P 0在while（flag[1]）语句中等待，而P 1在while（flag[0]）语句等待 F Bounded Waiting （3分） 4 不满足 Operating System Concepts 7. 157 Silberschatz, Galvin and Gagne 2002

2005年硕士研究生入学考试试题 1 （20分）设某计算机系统有一块CPU、一台输入设备、一台打印机。现有两个进程同时进入就绪状态，且进程A先得到CPU运行，进程B后运行。进程A的运行轨迹为：计算 50 ms, 打印 100 ms，再计算 50 ms，打印 100 ms，结束。进程B的运行轨迹为：计算 50 ms，输入数据 80 ms，再计算 100 ms，结束。试画出它们的时序关系图（可以用Gantt Chart），并说明：（1）开始运行后，CPU有无空闲等待? 若有，在哪段时间内等待？计算CPU的利用率（2）进程A运行时有无等待现象？若有，在什么时候发生等待现象？（3）进程B运行时有无等待现象？若有，在什么时候发生等待现象？ Operating System Concepts 7. 158 Silberschatz, Galvin and Gagne 2002

Exercises n 4, 8, 11 Operating System Concepts 7. 159 Silberschatz, Galvin and Gagne 2002