1 / 49

3.4 管程

3.4 管程. 3.4.1 管程和条件变量 3.4.2 霍尔方法实现 管程 3.4.3 汉森方法实现 管程. 3.4.1 什么 是 管程 ?(1) 为什么要引入管程. 把分散在各进程中的临界区集中起来进行管理 ； 防止进程有意或无意的违法同步操作， 便于用高级语言来书写程序，也便于程序正确性验证。. 什么 是 管程 ?(2). 管程是由局部于自己的若干公共变量及其说明和所有访问这些公共变量的过程所组成的软件模块. 管程有以下属性. • 共享性： • 安全性： • 互斥性：. 管程的基本形式. TYPE < 管程名 > = MONITOR

wyatt
Download Presentation

3.4 管程

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 3.4 管程 3.4.1 管程和条件变量 3.4.2 霍尔方法实现管程 3.4.3 汉森方法实现管程

  2. 3.4.1什么是管程?(1)为什么要引入管程 • 把分散在各进程中的临界区集中起来进行管理 ； • 防止进程有意或无意的违法同步操作， • 便于用高级语言来书写程序，也便于程序正确性验证。

  3. 什么是管程?(2) • 管程是由局部于自己的若干公共变量及其说明和所有访问这些公共变量的过程所组成的软件模块

  4. 管程有以下属性 •共享性： •安全性： •互斥性：

  5. 管程的基本形式 TYPE <管程名> = MONITOR <管程变量说明>; define <（能被其他模块引用的）过程名列表>; use <（要引用的模块外定义的）过程名列表>； procedure <过程名>(<形式参数表>); begin <过程体>； end; …… procedure <过程名>(<形式参数表>); begin <过程体>； end; begin <管程的局部数据初始化语句>； end;

  6. 等待调用的进程队列 入口 管程等待区域 管程 condition c1 局部数据 wait(c1) 条件变量 … 过程1 condition cn … wait(cn) 过程k Urgent queue 初始化代码 signal 出口 管程的结构

  7. 管程的示例 TYPE SSU = MONITOR var busy : boolean; nobusy : semaphore; define require, return; use wait, signal； procedure require; begin if busy then wait(nobusy); /*调用进程加入等待队列*/ busy := ture； end; procedure return; begin busy := false； signal(nobusy); /*从等待队列中释放进程*/ end; begin /*管程变量初始化*/ busy := false； end;

  8. 管程的条件变量(1) • 条件变量：当调用管程过程的进程无法运行时，用于阻塞进程的一种信号量 • 同步原语wait：当一个管程过程发现无法继续时，它在某些条件变量condition上执行wait，这个动作引起调用进程阻塞

  9. 管程的条件变量(2) • 另一个进程可以通过对其伙伴在等待的同一个条件变量condition上执行同步原语signal操作来唤醒等待进程。 • 条件变量与P、V操作中信号量的区别?

  10. 管程的问题讨论 使用signal释放等待进程时，可能出现两个进程同时停留在管程内。解决方法： • 执行signal的进程等待，直到被释放进程退出管程或等待另一个条件 • 被释放进程等待，直到执行signal的进程退出管程或等待另一个条件 霍尔采用了第一种办法；汉森选择了两者的折衷，规定管程中的过程所执行的signal操作是过程体的最后一个操作

  11. 管程与进程作比较(1) •管程定义的是公用数据结构，而进程定义的是私有数据结构； •管程把共享变量上的同步操作集中起来，而临界区却分散在每个进程中； •管程是为管理共享资源而建立的，进程主要是为占有系统资源和实现系统并发性而引入的；

  12. 管程与进程作比较(2) •管程是被欲使用共享资源的进程所调用的，管程和调用它的进程不能并行工作，而进程之间能并行工作，并发性是其固有特性； •管程是语言或操作系统的成分，不必创建或撤销，而进程有生命周期，由创建而产生至撤销便消亡。

  13. 3.4.2管程实现：Hoare方法 • 霍尔方法使用P和V操作原语来实现对管程中过程的互斥调用，及实现对共享资源互斥使用的管理。 • 不要求signal操作是过程体的最后一个操作，且wait和signal操作可被设计成可以中断的过程。

  14. Hoare管程数据结构(1) 1. mutex • 对每个管程，使用用于管程中过程互斥调用的信号量mutex（初值为1）。 • 进程调用管程中的任何过程时，应执行P(mutex)；进程退出管程时应执行V(mutex)开放管程，以便让其他调用者进入。 • 为了使进程在等待资源期间，其他进程能进入管程，故在wait操作中也必须执行V(mutex)，否则会妨碍其他进程进入管程，导致无法释放资源。

  15. Hoare管程数据结构(2) 2. next和next-count • 对每个管程，引入信号量next（初值为0），凡发出signal操作的进程应该用P(next)挂起自己，直到被释放进程退出管程或产生其他等待条件。 • 进程在退出管程的过程前，须检查是否有别的进程在信号量next上等待，若有，则用V(next)唤醒它。next-count（初值为0），用来记录在next上等待的进程个数。

  16. Hoare管程数据结构(3) 3. x-sem和x-count • 引入信号量x-sem（初值为0），申请资源得不到满足时，执行P(x-sem)挂起。由于释放资源时，需要知道是否有别的进程在等待资源，用计数器x-count（初值为0）记录等待资源的进程数。 • 执行signal操作时，应让等待资源的诸进程中的某个进程立即恢复运行，而不让其他进程抢先进入管程，这可以用V(x-sem)来实现。

  17. Hoare管程数据结构 每个管程定义如下数据结构 ： TYPE interf = RECORD • mutex:semaphore; /*进程调用管程过程前 使用的互斥信号量*/ • next:semaphore; /*发出signal的进程挂起 自己的信号量*/ • next_count:integer;/*在next上等待的进 程数*/ END;

  18. Hoare的wait操作 • Procedure wait(var x_sem:semaphore,x_count:integer, IM:interf); • begin • x_count := x_count + 1; • if IM.next_count > 0 then V(IM.next); • else V(IM.mutex); • P(x_sem); • X_count := x_count – 1; • end;

  19. Hoare的signal操作 • procedure signal(var x_sem:semaphore,x_count:integer, IM:interf); • begin • if x_count > 0 then begin • IM.next_count := IM.next_count + 1; • V(x_sem); • P(IM.next); • IM.next_count := IM.next_count - 1; • end; • end;

  20. Hoare的外部过程形式 任何一个调用管程中过程的外部过程应组织成下列形式，确保互斥地进入管程。 • P(IM.mutex); • <过程体>; • if IM.next_count > 0 then V(IM.next); • else V(IM.mutex);

  21. 霍尔方法实现五个哲学家吃通心面问题(1) • TYPE dining-philosophers = MONITOR • var state : array[0..4] of (thinking, hungry, eating); • s : array[0..4] of semaphore; • s-count : array[0..4] of integer; • define pickup, putdown; • use wait, signal；

  22. 霍尔方法实现五个哲学家吃通心面问题(2) • procedure test(k : 0..4); • begin • if state[(k-1) mod 5]<>eating and state[k]=hungry and state[(k+1) mod 5]<>eating then begin • state[k] := eating; • signal(s[k], s-count[k], IM); • end; • end;

  23. 霍尔方法实现五个哲学家吃通心面问题(3) • procedure pickup(i:0..4); • begin • state[i] := hungry; • test(i); • if state[i]<>eating then wait(s[i],s-count[i],IM)； • end;

  24. 霍尔方法实现五个哲学家吃通心面问题(4) • procedure putdown(i:0..4); • begin • state[i] := thinking; • test((i-1) mod 5); • test((i+1) mod 5); • end; • begin • for i := 0 to 4 do state[i] := thinking； • end;

  25. 霍尔方法实现五个哲学家吃通心面问题(6) • cobegin • process philosopher-i • begin • …… • P(IM.mutex); • call dining-philosopher.pickup(i); • if IM.next-count > 0 then V(IM.next); • else V(IM.mutex); • 吃通心面； • P(IM.mutex); • call dining-philosopher.putdown(i); • if IM.next-count > 0 then V(IM.next); • else V(IM.mutex); • …… • end; • coend;

  26. 管程实现：汉森方法(1) • 汉森方法的管程中的过程所执行的signal操作一定是过程体的最后一个操作，一个进程当所调用的过程执行了signal操作后，便立即退出了管程。 • 汉森方法使用四条原语：wait，signal，check，re1ease实现对管程的控制。

  27. 管程的实现：汉森方法(2) 每个管程使用的一个数据类型： TYPE interf = RECORD intsem : semaphore; /*开放管程的信号量 */ count1 : integer; /* 等待调用的进程个数 */ count2 : integer; /* 调用了管程中的过程且不 END; 处于等待状态的进程个数 */

  28. 管程的实现：汉森方法(3) • 调用查看原语check： 如果管程是开放的，则执行这条原语后关闭管程，相应进程继续执行；如果管程是关闭的，则执行这条原语后相应进程被置成等待调用状态

  29. 管程的实现：汉森方法(4) procedure check(var IM interf); begin if IM.count2 = 0 then IM.count2 := IM.count2 + 1; else begin IM.count1 := IM.count1 + 1; W(IM.intsem); end; end;

  30. 管程的实现：汉森方法(5) • 开放原语release： 如果除了发出这条原语的进程外，不再有调用了管程中过程但又不处于等待状态的进程，那么就释放一个等待者或开放管程

  31. 管程的实现：汉森方法(6) procedure release(var IM interf); begin IM.count2 := IM.count2 - 1; if IM.count2 = 0 and IM.count1 > 0 then begin IM.count1 := IM.count1 - 1; IM.count2 := IM.count2 + 1; R(IM.intsem); end; end;

  32. 管程的实现：汉森方法(7) • 等待原语wait： 执行这条原语后相应进程被置成等待状态，同时开放管程，允许其它进程调用管程中的过程

  33. 管程的实现：汉森方法(8) procedure wait(var s:semaphore; var IM interf); begin s := s + 1; IM.count2 := IM.count2 – 1; if IM.count1 > 0 then begin IM.count1 := IM.count1 – 1; IM.count2 := IM.count2 + 1; R(IM.intsem); end; W(s); end;

  34. 管程的实现：汉森方法(9) • 释放原语signal： 执行这条原语后释放指定等待进程队列中的一个进程。如指定等待进程队列为空，本操作相当于空操作

  35. 管程的实现：汉森方法(10) procedure signal(var s:semaphore; var IM interf); begin if s > 0 then begin s := s – 1; IM.count2 := IM.count2 + 1; R(s); end; end;

  36. 管程的实现：汉森方法(11) 用管程实现进程同步时，进程应按下列次序工作： • 请求资源。 • 使用资源。 • 释放资源。

  37. 汉森方法实现读者写者问题(1) 有两组并发进程：读者与写者，共享一个文件，要求：1）允许多个读者同时执行读操作；2）任一写者在完成写操作之前不允许其他读者和写者工作；3）写者欲工作，要等待已存在的读者完成读操作，新的读者与写者均被拒绝

  38. 汉森方法实现读者写者问题(2) • type read-writer = MONITOR • var rc, wc : integer; • R, W : semaphore; • define start-read, end-read, start-writer, end-writer; • use wait, signal, check, release;

  39. 汉森方法实现读者写者问题(3) procedure start-read; begin check(IM); if wc>0 then wait(R,IM); rc := rc + 1; signal(R, IM); release(IM); end; procedure end-read; begin check(IM); rc := rc - 1; if rc=0 then signal(W,IM); release(IM); end;

  40. 汉森方法实现读者写者问题(4) procedure start-write; begin check(IM); wc := wc + 1; if rc>0 or wc>1 then wait(W,IM); release(IM); end; procedure end-write; begin check(IM); wc := wc - 1; if wc>0 then signal(W,IM); else signal(R, IM); release(IM); end;

  41. 汉森方法实现读者写者问题(5) 初始化语句 begin rc := 0; wc := 0; R := 0; W := 0; end;

  42. 汉森方法实现读者写者问题(6) • cobegin • process reader • begin • …… • call read-writer.start-read; • read; • …… • call read-writer.end-read; • end; • process writer • begin • …… • call read-writer.start-write; • write; • …… • call rear-writer.end-write; • end; • coend;

  43. 汉森方法实现苹果橘子问题(1) 桌上有一只盘子，每次只能放入一只水果，爸爸专向盘中放苹果，妈妈专向盘中放橘子，一个儿子专吃盘中橘子，一个女儿专吃盘中苹果

  44. 汉森方法实现苹果橘子问题(2) • TYPE FMSD = MONITOR • var plate : (apple, orange); • full : boolean; • SP, SS, SD : semaphore; • define put, get; • use wait, signal, check, release;

  45. 汉森方法实现苹果橘子问题(3) • procedure put(var fruit:(apple, orange)); • begin • check(IM); • if full then wait(SP,IM); • full := true; • plate := fruit; • if fruit=orange • then signal(SS,IM); • else signal(SD,IM); • release(IM); • end;

  46. 汉森方法实现苹果橘子问题(4) • procedure get(varfruit:(apple,orange),x:plate); • begin • check(IM); • if not full or plate<>fruit • then begin • if fruit = orange • then wait(SS,IM); • else wait(SD,IM); • end; • x := plate; • full := false; • signal(SP, IM); • release(IM); • end;

  47. 汉森方法实现苹果橘子问题(5) 初始化语句 begin full := false; SP := 0; SS := 0; SD := 0; end;

  48. 汉森方法实现苹果橘子问题(6) • cobegin • process father • begin • …… • 准备好苹果; • call FMSD.put(apple); • end; • process mother • begin • …… • 准备好桔子; • call FMSD.put(orange); • end;

  49. 汉森方法实现苹果橘子问题(7) • process son • begin • …… • call FMSD.get(orange,x); • 吃取到的桔子; • …… • end; • process daughter • begin • …… • call FMSD.get(apple,x); • 吃取到的苹果; • end; • coend;

More Related