管程求解哲学家就餐问题.更细的演算步骤

最新推荐文章于 2022-02-18 18:54:54 发布
最新推荐文章于 2022-02-18 18:54:54 发布
阅读量2.4k 收藏 12
点赞数 3
分类专栏： 操作系统 文章标签： 操作系统 PV增量与管程

enum {thinking,hungry,eating} state[5];

semaphore self[5];//Hoare方法数据结构和enter、wait、signal及leave操作

typedef struct InterfaceModule { //InterfaceModule是结构体的名字

semaphore mutex;             //进程调用管程过程前使用的互斥信号量

semaphore next;              //发出signal的进程挂起自己的信号量

int next_count;              //在next上等待的进程数

};

mutex=1;next=0;next_count=0;//初始化语句

void enter(InterfaceModule &IM) {

P(IM.mutex);             //互斥进入管程

}

void leave(InterfaceModule &IM) {

   if(IM.next_count>0)       //判有否发出过signal的进程?

V(IM.next);          //有就释放一个发出过signal的进程

else

    V(IM.mutex);         //否则开放管程

}

void wait(semaphore &x_sem,int &x_count,InterfaceModule &IM) {

x_count++;              //等资源进程个数加1，x_count初始化为0

if(IM.next_count>0)     //判有否发出过signal的进程

   V(IM.next);          //有就释放一个

else 

   V(IM.mutex);        //否则开放管程

 P(x_sem);              //等资源进程阻塞自己，x_sem初始化为0

x_count--;               //等资源进程个数减1 

}

void signal(semaphore &x_sem,int &x_count,InterfaceModule &IM) {

if(x_count>0) {           //有等资源进程吗?

   IM.next_count++;       //发出signal进程个数加1

   V(x_sem);              //释放一个等资源的进程

   P(IM.next);           //发出signal进程阻塞自己

       IM.next_count--;      //发出signal进程个数减1

 }

}

 

IM.mutex=1; next=0; next_count=0; self[i]=0; self_count=0; state[i]=thinking; 

mutex=1;next=0;next_count=0; 

 


3.4.3 使用管程解决进程同步问题

1 管程解决五个哲学家吃通心面问题

首先，引入枚举类型enum {thinking,hungry,eating} state[5]表示哲学家的状态，哲学家i能建立状态state［i］=eating，仅当他的两个邻座不在吃的时候，即state［(i-1)%5］!=eating及state［(i+1)%5］!=eating；另外还要引入条件变量(信号量)：semaphore self[5]，当哲学家i饥饿但又不能获得两把叉子时，进入其信号量等待队列。

 

说明: 在释放叉子的时候，唤醒左邻居和右邻居。如果以顺时针编号，对于i号哲学家，(i-1)%5是i号哲学家的右邻居，(i+1)%5是i号哲学家的左邻居。每个哲学家在三个状态(thinking,hungry,eating)中变换，其中是hungry是thinking向eating的过渡状态。

 

//霍尔方法实现哲学家吃通心面问题

type dining_philosophers=monitor

 

int self_count[5];

InterfaceModule IM;

for (int i=0;i<5;i++)      //初始化，i为进程号

    state[i]=thinking;

define pickup,putdown;

use enter,leave,wait,signal；

void pickup(int i) {        //i=0,1,...,4

    enter(IM);

state[i]=hungry;

test(i);

if(state[i]!=eating)

wait(self[i],self_count[i],IM);

    leave(IM);

}

void putdown(int i) {       //i=0,1,2,..,4

   enter(IM);

state[i]=thinking;

test((i-1)%5);

test((i+1)%5);

   leave(IM);

}

void test(int k)  {       //k=0,1,...,4

if((state[(k-1)%5]!=eating)&&(state[k]==hungry)

&&(state[(k+1)%5]!=eating)) {

state[k]=eating;

signal(self[k],self_count[k],IM);

}

}

}

任一个哲学家想吃通心面时调用过程pickup，吃完通心面之后调用过程putdown。

cobegin              

process philosopher_i( ) {  //i=0,…,4

   while(true) {

    thinking( );

dining_philosophers.pickup(i);        

 eating( );

dining_philosophers.putdown(i);

      }

 }

coend


场景分析

 

 

注明self[i]初值都为0，self_count[i]初值为0，IM.next初值为0，next_count初值为0。IM.mutex初值为1，表示管程互斥。

实际场景解析：以此图为例，5个哲学家的编号如图所示。假设整个场景的序列是(A) 3号取得叉子，吃；(B) 1接着取得叉子，吃；(C) 2准备取叉子，等待邻居释放叉子；(D) 1号放叉子，试图唤醒2号，不成。(E) 3号放叉子，唤醒2号，成功，2号取到叉子，吃；(F) 1号想再取叉子，因2号在吃等待。这个场景详细描述较长，耐心阅读。

 

调用进程

被调用的操作

信号量状态

1. 

P3

pickup

IM.mutex=1; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking;

2. 

P3

enter(IM)

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking;

3. 

P3

State[3]=hungry

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]=hungry;

4. 

P3

test(3)

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]=hungry;

5. 

P3

State[3]=eating

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating;

6. 

P3

Signal(self[3])

//空操作

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating;

7. 

P3

leave(IM)

IM.mutex=1; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating;

8. 

P1

pickup

IM.mutex=1; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating;

9. 

P1

enter(IM)

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating;

10. 

P1

State[1]=hungry

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating; state[1]=hungry;

11. 

P1

test(1)

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating; state[1]=hungry;

12. 

P1

State[1]=eating

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating; state[1]= eating;

13. 

P1

Signal(self[1])

//空操作

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating; state[1]= eating;

14. 

P3

leave(IM)

IM.mutex=1; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating; state[1]= eating;

15. 

P2

pickup

IM.mutex=1; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating; state[1]= eating;

16. 

P2

enter(IM)

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating; state[1]= eating;

17. 

P2

State[2]=hungry

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating; state[1]= eating; state[2]= hungry;

18. 

P2

test(2)

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[3]= eating; state[1]= eating; state[2]= hungry;

19. 

P2

wait(self[2])

//

IM.mutex=1; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[3]=eating; state[1]= eating; state[2]= hungry;

20. 

P1

putdown

IM.mutex=1; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[3]=eating; state[1]= eating; state[2]= hungry;

21. 

P1

enter(IM)

IM.mutex=0; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[3]=eating; state[1]= thinking; state[2]= hungry;

22. 

P1

State[1]=thinking

IM.mutex=0; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[3]=eating; state[1]= thinking; state[2]= hungry;

23. 

P1

test(0)

IM.mutex=0; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[3]=eating; state[1]= thinking; state[2]= hungry;

24. 

P1

test(2)

IM.mutex=0; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[3]=eating; state[1]= thinking; state[2]= hungry;

25. 

P1

leave(IM)

IM.mutex=1; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[3]=eating; state[1]= thinking; state[2]= hungry;

26. 

P3

putdown

IM.mutex=1; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[3]=eating; state[1]= thinking; state[2]= hungry;

27. 

P3

enter(IM)

IM.mutex=0; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[3]=eating; state[1]= thinking; state[2]= hungry;

28. 

P3

State[3]=thinking

IM.mutex=0; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[2]= hungry;

29. 

P3

test(2)

//序30, 31, 34

IM.mutex=0; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[2]= hungry;

30. 

P3

State[2]=eating

//P3.test(2)中

IM.mutex=0; next=0; next_count=0; self[i]=0; self[2]=-1 (P2); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[2]= eating;

31. 

P3

Signal(self[2])

//P3.test(2)中

IM.mutex=0; next=-1 (P3); next_count=1; self[i]=0; self[2]=0 P2 (); self_count[i]=0; self_count[2]=1; state[i]=thinking; state[2]= eating;

32. 

P2

Self_count[2]—

//P2.P(wait)的末尾语句

IM.mutex=0; next=-1 (P3); next_count=1; self[i]=0; self_count[i]=0; self_count[2]=0; state[i]=thinking; state[2]= eating;

33. 

P2

leave(IM)

//P2.pickup中的

IM.mutex=0; next=0 P3 (); next_count=1; self[i]=0; self_count[i]=0; state[i]=thinking; state[2]= eating;

34. 

P3

next_count--

//P3.test(2)中的signal(self[2])的末尾语句

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[2]= eating;

35. 

P3

test(4)

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[2]= eating;

36. 

P3

leave(IM)

//P3.putdwon的末尾语句

IM.mutex=1; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[2]= eating;

37. 

P1

Pickup

IM.mutex=1; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[2]= eating;

38. 

P1

Enter(IM)

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; state[i]=thinking; state[2]= eating;

39. 

P1

State[1]=hungry

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; self_count[2]=0; state[i]=thinking; state[1]=hungry; state[2]= eating;

40. 

P1

Test(1)

IM.mutex=0; next=0; next_count=0; self[i]=0; self_count[i]=0; self_count[2]=0; state[i]=thinking; state[1]=hungry; state[2]= eating;

41. 

P1

Wait(self[1])

IM.mutex=1; next=0; next_count=0; self[i]=0; self[1]=-1 (P1); self_count[i]=0; self_count[1]=1; state[i]=thinking; state[1]=hungry; state[2]= eating;

42. 

P2

Putdown 

IM.mutex=1; next=0; next_count=0; self[i]=0; self[1]=-1 (P1); self_count[i]=0; self_count[1]=1; state[i]=thinking; state[1]=hungry; state[2]= eating;

43. 

P2

enter(IM)

IM.mutex=0; next=0; next_count=0; self[i]=0; self[1]=-1 (P1); self_count[i]=0; self_count[1]=1; state[i]=thinking; state[1]=hungry; state[2]= eating;

44. 

P2

State[2]=thinking

IM.mutex=0; next=0; next_count=0; self[i]=0; self[1]=-1 (P1); self_count[i]=0; self_count[1]=1; state[i]=thinking; state[1]=hungry; state[2]= thinking;

45. 

P2

test(1)

//序

IM.mutex=0; next=0; next_count=0; self[i]=0; self[1]=-1 (P1); self_count[i]=0; self_count[1]=1; state[i]=thinking; state[1]=hungry; state[2]= thinking;

46. 

P2

State[1]=eating

//P2.test(1)中

IM.mutex=0; next=0; next_count=0; self[i]=0; self[1]=-1 (P1); self_count[i]=0; self_count[1]=1; state[i]=thinking; state[1]=eating; state[2]= thinking;

47. 

P2

Signal(self[2])

//P3.test(2)中

IM.mutex=0; next=-1 (P2); next_count=1; self[i]=0; self[1]=0 P1 (); self_count[i]=0; self_count[1]=1; state[i]=thinking; state[1]=eating; state[2]= thinking;

48. 

P1

Self_count[1]—

//P1.P(wait)的末尾语句

IM.mutex=0; next=-1 (P2); next_count=1; self[i]=0; self[1]=0 P1 (); self_count[i]=0; self_count[1]=0; state[i]=thinking; state[1]=eating; state[2]= thinking;

49. 

P1

leave(IM)

//P1.pickup中的

IM.mutex=0; next=0 P2 (); next_count=1; self[i]=0; self[1]=0 P1 (); self_count[i]=0; self_count[1]=0; state[i]=thinking; state[1]=eating; state[2]= thinking;

50. 

P2

next_count--

//P2.test(1)中的signal(self[1])的末尾语句

IM.mutex=0; next=0; next_count=0; self[i]=0; self[1]=0 P1 (); self_count[i]=0; self_count[1]=0; state[i]=thinking; state[1]=eating; state[2]= thinking;

51. 

P2

test(3)

IM.mutex=0; next=0; next_count=0; self[i]=0; self[1]=0 P1 (); self_count[i]=0; self_count[1]=0; state[i]=thinking; state[1]=eating; state[2]= thinking;

52. 

P2

leave(IM)

//P2.putdwon的末尾语句

IM.mutex=1; next=0; next_count=0; self[i]=0; self[1]=0 P1 (); self_count[i]=0; self_count[1]=0; state[i]=thinking; state[1]=eating; 

53. 

 

 

 

 

(A) 假设一开始3号哲学家，第一个做pickup，他会很顺畅，在pickup中通过enter(IM)进入管程，修改自身状态state[3]=hungry, 接着test(3)中if条件通过，修改自身状态state[3]=eating, 因为这时候没有进程(哲学家)阻塞在self[3]上，即self_count[3]==0，对照signal(self[3], self_count[3], IM)中的PV实现，实际上此时signal什么也不做。然后，判断if (state[3]!=eating)不成立，因此wait操作也不做。再然后，3号哲学家执行leave(IM)退出管程，以便让其他哲学家进入管程。
分析：实际上这里3号哲学家成功的取到他需要的两个叉子。他通过将自己的状态改为eating，对于i=2号哲学家在取叉子的时需要做test(i)，state[i+1]!=eating不成立；对于i=4号哲学家在取叉子的时需要做test(i)，state[i-1]!=eating不成立；从而封堵其左右哲学家转入eating状态，2、4号哲学家不能成功转入eating状态，将执行wait操作，也即在3号哲学家没有执行putdown中的test((i-1)%5)和test((i+1)%5)之前，左右哲学家不能成功取到叉子。

(B) 接着，在3号哲学家还没有putdown之前，如果1号哲学家执行pickup，他也会很顺畅，与之前的3号哲学家pickup时的情形类似，在pickup中通过enter(IM)进入管程，修改自身状态state[1]=hungry, 接着test(1)中if条件通过，修改自身状态state[1]=eating, 因为这时候没有进程(哲学家)阻塞在self[1]上，即self_count[1]==0，对照signal(self[1], self_count[1], IM)中的PV实现，实际上此时signal什么也不做。然后，判断if (state[1]!=eating)不成立，因此wait操作也不做。再然后，3号哲学家执行leave(IM)退出管程，以便让其他哲学家进入管程。
分析：实际上这里1号哲学家成功的取到他需要的两个叉子。他通过将自己的状态改为eating，从而封堵其左右哲学家转入eating状态，0、2号哲学家不能成功转入eating状态，也即在1号哲学家没有执行putdown中的test((i-1)%5)和test((i+1)%5)之前，不能成功取到叉子。

(C) 接着，在1和3号哲学家没有putdown之前，此时，state[1]==eating，state[3]==eating。如果2号哲学家执行pickup，他会很不顺畅，在pickup中通过enter(IM)进入管程，修改自身状态state[2]=hungry，接着test(2)中的if条件state[1]!=eating，state[3]!=eating都不成立，因此2号哲学家没有成功把自身状态修改为eating，也不用做test(2)中signal(self[2], self_count[2], IM)操作，再接着判断if (state[2]!=eating)成立，因此做wait(self[2], self_count[2], IM)操作，对照wait操作的PV实现，此时，self[2]_count++表示在self[2]等待的进程数加1，然后判断if (IM.next_count>0)，如果此时1和3号进程都没有执行putdown中的signal操作，那么该条件不成立，然后执行V(IM.mutex)退出管程，接着P(self[2])阻塞自己，等待1和3号哲学家执行putdown中的signal操作唤醒之。

(D) 接着，假设1号哲学家吃完，执行putdown，在putdown中通过enter(IM)进入管程，并修改自身状态state[1]=thinking，然后test((i-1)%5)，即test(0)，其中state[(0-1)%5]即state[4]!=eating成立，state[0]==hungry不成立(表示0号哲学家没有执行pickup)，state[(0+1)%5]即state[1]!=eating成立，即整个if条件不成立，if下的语句不做。然后test((i+1)%5)，即test(2)，其中state[(2-1)%5]即state[1]!=eating成立，state[2]==hungry(表示之前2号哲学家已经执行了pickup，且没有成功取到叉子)，state[(2+1)%5]即state[3]!=eating不成立，即整个if条件还是不成立，然后1号哲学家执行leave(IM)退出管程，以便其他哲学家进入管程。
分析: 1号哲学在putdown的时候执行test(0)和test(2)，test(0)用意在于唤醒右邻居0号哲学家，但是0号哲学家还没有执行pickup，也就没有把自身状态修改为hungry，1号哲学家的这份好心浪费了；接着test(2)用意在于唤醒左邻居2号哲学家，但是2号哲学家成功取到叉子之前要判断3号是否eating，实际上此时3号依然eating，因此test(2)的用意没有真正成功。看来还真不简单，不要紧，继续往下看。

(E) 当1号哲学家在putdown中退出管程，此时state[1]==thinking，state[2]==hungry，假设此时3号哲学家开始执行putdown，在putdown中通过enter(IM)进入管程，并修改自身状态state[3]=thinking，然后test((i-1)%5)，即test(2)，其中state[(2-1)%5]即state[1]!=eating成立，state[2]==hungry成立(表示之前2号哲学家已经执行了pickup，且没有成功取到叉子)，state[(2+1)%5]即state[3]!=eating成立，即整个if条件成立，看到希望了，接着执行signal(self[2], self_count[2], IM)，因为之前，2号哲学家已经在self[2]上等待许久了，对照signal操作的PV实现，self_count[2]>0，执行IM.next_count++，V(self[2]) (注:终于把2号哲学家等待许久的self[2]释放，唤醒2号哲学家)，P(IM.next)阻塞自己。
分析：对于2号哲学家被唤醒之后，他将执行其pickup中P(self[2])之后的语句，self_count[2]--，即self_count[2]恢复为0，并最终执行pickup中leave(IM)，在leave(IM)中参考Hoare管程leave操作的PV实现，判断if (IM.next_count)>0成立，则执行V(IM.next) 唤醒3号哲学家之前在P(IM.next)上的等待，并有机会执行后续语句IM.next_count--，即计数恢复为0，最终执行putdown中的leave(IM)退出管程，以便其他进程能够再进入管程，这里可以看出对于Hoare管程的实现，signal操作不必是过程体的最后一个操作。对于3号哲学家通过test(2)完成了唤醒2号哲学家的任务，然而他自己暂时阻塞在IM.next上，暂时不能执行putdown中后续的test((i+1)%5)，即不能执行test(4)。

(F) 接着，假设在2号哲学家被唤醒取到叉子之后开始吃，3号哲学家执行完putdown中的leave(IM)退出管程，如果1号哲学家想再一次取叉子，此时state[0]==state[3]==thinking，state[2]==eating，1号不如之前顺畅，在pickup中通过enter(IM)进入管程，修改自身状态state[1]=hungry, 接着test(1)中，state[2]!=eating不成立，即if条件不通过，因此1号哲学家没有成功把自身状态修改为eating，也不用做test(1)中signal(self[1], self_count[1], IM)操作，再接着判断if (state[1]!=eating)成立，因此做wait(self[1], self_count[1], IM)操作，对照wait操作的PV实现，此时，self[1]_count++表示在self[1]等待的进程数加1，然后判断if (IM.next_count>0)，如果此时2号进程还没有执行putdown中的signal操作，那么该条件不成立，然后执行V(IM.mutex)退出管程，接着P(self[1])阻塞自己，等待2号哲学家执行putdown中的signal操作唤醒之。
分析: 到此为止，2号哲学家状态为eating正在吃，还没有执行putdown，1号哲学家因为左邻居2号在eating，被阻塞在self[1]上，等待2号执行putdown的时候唤醒之。后续的场景演绎依照上述思路展开，不再赘述。

 

 

 

 

jiangzexin
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用管程概念求解哲学家进餐问题1
08-03
《利用管程概念求解哲学家进餐问题》 哲学家进餐问题，作为操作系统中的经典同步问题，涉及到多进程或线程间的资源分配，旨在避免死锁的发生。本文介绍了一种利用管程概念解决这一问题的方法，并与传统方法进行了...
哲学家就餐问题之管程
qq_41438541的博客
03-31 2501
*利用管程机制实现。 原理：不是对每只筷子设置信号量，而是对每个哲学家设置信号量。 test()函数有以下作用： a.如果当前处理的哲学家处于饥饿状态并且两侧的哲学家不在吃饭状态 则当前哲学家通过test函数试图进入吃饭状态 b.如果通过test进入吃饭状态不成功，那么当前的哲学家就在该信号量阻塞等待 直到其他哲学家进程通过test将该哲学家的状态设置为eating c.当一个哲学家进程调用pu...
经典的进程同步问题-----哲学家进餐问题详解
热门推荐
丹丹的后花园
11-25 3万+
​ 本文和接下来几篇博文是对上篇文章（进程同步机制）的一次实践，通过具体的例子来加深理论的理解，会用三个经典的进程同步问题来进行讲解，并且会配有伪代码和Java实践（使用多线程模拟），深入的进行讲解。 ​ 进程同步问题是一个非常重要且相当有趣的问题，本文我们对其中比较有名的哲学家进餐问题来进行探讨。哲学家进餐问题是诸进程间竞争临界资源而导致死锁的典型例子，具有很大的代表性，因此在这里我们也对其进行...
吸烟者问题、读者—写者问题以及哲学家进餐问题的实现
派拉斯兔子的博客
08-23 630
一、吸烟者问题 假设一个系统有三个抽烟者进程和一个供应者进程。每个抽烟者不停地卷烟并抽掉它，但是要卷起并抽掉一支烟，抽烟者需要有三种材料：烟草、纸和胶水。三个抽烟者中，第一个拥有烟草、第二个拥有纸、第三个拥有胶水。供应者进程无限地提供三种材料，供应者每次将两种材料放桌子上，拥有剩下那种材料的抽烟者卷一根烟并抽掉它，并给供应者进程一个信号告诉完成了，供应者就会放另外两种材料再桌上，这个过程一直重复（让三个抽烟者轮流地抽烟） 本质上这题也属于“生产者-消费者”问题，更详细的说应该是“可生产多种产品的单生产者
《操作系统》-管程
weixin_52786722的博客
02-18 1647
为什么要引入管程 信号量作为高层抽象与P、V操作一起来解决了绝大部分的进程同步问题。但这种解决方法也有一定的缺陷： (1)程序易读性差，因为要了解对于信息量的操作是否正确需要读懂整个系统活着并发程序。 (2)程序不利于修改或维护，因为程序的局部性很差，所以对任意一组变量一段代码的修改都有可能影响全局。 (3)正确性难以保证，因为操作系统或并发程序通常很大，要保证这样一个复杂的系统，没有逻辑错误是很难的 (4)容易发生死锁的情况，如果程序员不使用好P、V操作时，逻辑上发生错误，很有可能会导致死锁的发生。 那么
操作系统 管程实现 哲学家就餐问题
05-26
操作系统中的管程实现是解决并发控制的一种有效方法，而哲学家就餐问题则是并发控制的经典案例，用于演示和分析死锁的可能情况。本文将详细探讨这两个主题，旨在深入理解操作系统中的并发控制机制以及如何避免死锁。...
JAVA管程解决哲学家就餐问题
03-05
在Java中，通过管程解决哲学家就餐问题通常包括以下几个步骤： 1. **创建筷子对象**：每个筷子都是一个对象，具有被获取和释放的状态。使用`Lock`或`ReentrantLock`来保证筷子的互斥访问。 2. **创建哲学家对象**...
JAVA管程解决哲学家问题
12-01
哲学家问题（Dining Philosophers Problem）是计算机科学中的一个经典问题，用于演示并发控制中的死锁现象。在这个问题中，五个哲学家围坐在一张圆桌旁，每人一边有一根筷子。当哲学家想要吃饭时，他需要同时拿起...
java模拟的5个哲学家就餐问题 使用管程 输出资源分配历史状态 具备图形界面
12-04
使用管程方式模拟哲学家就问题。 用一个输入变量控制是否有左撇子哲学家，如果有，其数量由随机数生成； 模拟程序分为两种情况： 1.可能发生死锁的情况； 2.没有死锁发生的情况。 可输出资源分配给哲学家的当前状态...
操作系统学习笔记（十三）~读者写者问题+哲学家就餐问题+管程
海到无边天作岸 山登绝顶我为峰
04-06 3842
6.4 读者写者问题 1、在读者写者问题中，能同时执行读写的是（）。C A.读者和写者 B.不同写者 C.不同读者 D.都不能 2、在读者优先的读者写者问题中，读者可以进入读的前提是（）。A、B A.没有读者和写者在读写 B.有读者在读 C.有写者在写 D.有写者在等 3、在读者代码 rc–; If (rc==0) V(W) 中V(W)可能唤醒其它读者。× 解释：执行到这一步 说明已经是最后一个读...
经典的哲学家就餐问题笔记
Monster丶ZF的博客
05-14 3645
以哲学家问题来总结归纳解决死锁问题的各种方法，哲学家进餐问题是一个经典的进程之间的同步互斥问题。 问题描述就是： 1、有五个哲学家围坐在一圆桌旁，桌中央有一盘通心粉，每人面前有一只空盘子，每两人之间放一只筷子 2、每个哲学家的行为是思考，感到饥饿，然后吃通心粉 3、为了吃通心粉，每个哲学家必须拿到两只筷子，并且每个人只能直接从自己的左边或者后边去取筷子（筷子的互斥使用、不能出现死锁的现象） 问题...
哲学家就餐问题——信号量/管程
amara
03-11 1843
问题 应用程序中包含并发线程的执行时，协调处理共享资源的代表性问题 五位哲学家住在一座房子，他们面前有一张餐桌，每个哲学家生活中只有思考和吃饭。经多年思考，哲学家们认为最有助于思考的事物是意大利面。因缺乏手工功能，每位哲学家需要用两把叉子来吃意大利面。如图： 每个哲学家面前有个盘子，左右两边各一个叉子。现在设计一个算法来让哲学家就餐。算法必须互斥(没有两个哲学家能同时用一把叉子)，同时要避免死锁...
关于哲学家进餐问题
ikikray的专栏
04-02 1万+
操作系统并发和互斥：哲学家进餐问题和理发师问题 1． 哲学家进餐问题： (1) 在什么情况下5 个哲学家全部吃不上饭？ 考虑两种实现的方式，如下： A. 算法描述： void philosopher(int i) /*i：哲学家编号，从0 到4*/ { while (TRUE) { think( ); /*哲学家正在思考*/ take_fork(i); /*取左侧的筷子*/ take_fork((
哲学家就餐问题及其实现
Shine__Wong的博客
09-30 4616
哲学家就餐问题描述 哲学家就餐问题是指，有五个哲学家围坐一桌，每两个哲学家之间都有一只叉子，一共有五只叉子。每个哲学家都只有两个动作，即思考和就餐，哲学家思考的时候不需要任何的资源，但只有同时拿起他左右的两只叉子，才能开始进餐。进餐完毕后将叉子放归原位。这个问题在于，应该如何保证哲学家们的动作有序进行，如不会出现有人永远拿不到叉子的情况。 一些初步的尝试 第一次尝试 对哲学家就餐问题进行分析，可以...
哲学家进餐问题
无关风月
07-25 3684
哲学家进餐问题 并发进程并发执行时处理共享资源的一个有代表性的问题 在一个圆桌上，有n个哲学家，n只筷子，每个哲学家左右两边各返一只筷子。哲学家可以进行思考和吃饭，思考时，不获取筷子。吃饭时，必须同时获得左右两只筷子才能吃饭（先获得左边，再获得右边）。 5名哲学家与左右邻居对其中间筷子的访问是互斥关系。定义互斥信号量 chopstick[5]={1,1,1,1,1} 用于对5个筷子的互...
哲学家就餐问题的分析与解决方案
Sunflowerfiona的博客
10-08 2万+
1.进程互斥与同步，死锁基本知识在多道程序环境下，进程有异步和同步两种并发执行方式。异步执行是指运行中的各进程在操作系统的调度下以不可预知的速度向前推进。异步执行的进程大多没有时序要求，不存在“执行结果与语句的特定执行顺序有关”的条件竞争。然而存在一类协作进程，“保证数据的一致性” 的前提要求它们必须按某种特定顺序执行，并且遵守如下两种限制。 （1）Ｒ１（顺序化执行）：进程A 的eventA事件必
（操作系统原理·第三章）五个哲学家吃通心面 问题
aquial的博客
03-17 5960
进程同步
管程方法提升哲学家进餐问题求解的模块化与可读性
"本文主要探讨了如何利用管程概念来解决经典的哲学家进餐问题。哲学家进餐问题是一个多进程同步问题，涉及资源分配和避免死锁。传统的哲学家问题中，若无约束，可能导致所有哲学家同时持有部分资源而无法进食，即...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值