理发师问题java代码 理发师在线问答

哲学家进餐问题（在计算机操作系统方面的相关编程）

操作系统并发和互斥：哲学家进餐问题和理发师问题

1． 哲学家进餐问题：

(1) 在什么情况下5 个哲学家全部吃不上饭？

考虑两种实现的方式，如下：

A.

算法描述：

void philosopher(int i) /*i：哲学家编号，从0 到4*/

{

while (TRUE) {

think( ); /*哲学家正在思考*/

take_fork(i); /*取左侧的筷子*/

take_fork((i+1) % N); /*取左侧筷子；％为取模运算*/

eat( ); /*吃饭*/

put_fork(i); /*把左侧筷子放回桌子*/

put_fork((i+1) % N); /*把右侧筷子放回桌子*/

}

}

分析：假如所有的哲学家都同时拿起左侧筷子，看到右侧筷子不可用，又都放下左侧筷子，

等一会儿，又同时拿起左侧筷子，如此这般，永远重复。对于这种情况，即所有的程序都在

无限期地运行，但是都无法取得任何进展，即出现饥饿，所有哲学家都吃不上饭。

B．

算法描述：

规定在拿到左侧的筷子后，先检查右面的筷子是否可用。如果不可用，则先放下左侧筷子，

等一段时间再重复整个过程。

分析：当出现以下情形，在某一个瞬间，所有的哲学家都同时启动这个算法，拿起左侧的筷

子，而看到右侧筷子不可用，又都放下左侧筷子，等一会儿，又同时拿起左侧筷子……如此

这样永远重复下去。对于这种情况，所有的程序都在运行，但却无法取得进展，即出现饥饿，

所有的哲学家都吃不上饭。

(2) 描述一种没有人饿死（永远拿不到筷子）算法。

考虑了四种实现的方式（A、B、C、D）：

A．原理：至多只允许四个哲学家同时进餐,以保证至少有一个哲学家能够进餐,最终总会释

放出他所使用过的两支筷子,从而可使更多的哲学家进餐。以下将room 作为信号量，只允

许4 个哲学家同时进入餐厅就餐，这样就能保证至少有一个哲学家可以就餐，而申请进入

餐厅的哲学家进入room 的等待队列，根据FIFO 的原则，总会进入到餐厅就餐，因此不会

出现饿死和死锁的现象。

伪码：

semaphore chopstick[5]={1，1，1，1，1};

semaphore room=4;

void philosopher(int i)

{

while(true)

{

think();

wait(room); //请求进入房间进餐

wait(chopstick[i]); //请求左手边的筷子

wait(chopstick[(i+1)%5]); //请求右手边的筷子

eat();

signal(chopstick[(i+1)%5]); //释放右手边的筷子

signal(chopstick[i]); //释放左手边的筷子

signal(room); //退出房间释放信号量room

}

}

B．原理：仅当哲学家的左右两支筷子都可用时,才允许他拿起筷子进餐。

方法1：利用AND 型信号量机制实现：根据课程讲述，在一个原语中，将一段代码同时需

要的多个临界资源，要么全部分配给它，要么一个都不分配，因此不会出现死锁的情形。当

某些资源不够时阻塞调用进程;由于等待队列的存在，使得对资源的请求满足FIFO 的要求，

因此不会出现饥饿的情形。

伪码：

semaphore chopstick[5]={1，1，1，1，1};

void philosopher(int I)

{

while(true)

{

think();

Swait(chopstick[(I+1)]%5,chopstick[I]);

eat();

Ssignal(chopstick[(I+1)]%5,chopstick[I]);

}

}

方法2：利用信号量的保护机制实现。通过信号量mutex对eat（）之前的取左侧和右侧筷

子的操作进行保护，使之成为一个原子操作，这样可以防止死锁的出现。

伪码：

semaphore mutex = 1 ;

semaphore chopstick[5]={1，1，1，1，1};

void philosopher(int I)

{

while(true)

{

think();

wait(mutex);

wait(chopstick[(I+1)]%5);

wait(chopstick[I]);

signal(mutex);

eat();

signal(chopstick[(I+1)]%5);

signal(chopstick[I]);

}

}

C． 原理：规定奇数号的哲学家先拿起他左边的筷子,然后再去拿他右边的筷子;而偶数号

的哲学家则相反.按此规定,将是1,2号哲学家竞争1号筷子,3,4号哲学家竞争3号筷子.即

五个哲学家都竞争奇数号筷子,获得后,再去竞争偶数号筷子,最后总会有一个哲学家能获

得两支筷子而进餐。而申请不到的哲学家进入阻塞等待队列，根FIFO原则，则先申请的哲

学家会较先可以吃饭，因此不会出现饿死的哲学家。

伪码：

semaphore chopstick[5]={1，1，1，1，1};

void philosopher(int i)

{

while(true)

{

think();

if(i%2 == 0) //偶数哲学家，先右后左。

{

wait (chopstick[ i + 1 ] mod 5) ;

wait (chopstick[ i]) ;

eat();

signal (chopstick[ i + 1 ] mod 5) ;

signal (chopstick[ i]) ;

}

Else //奇数哲学家，先左后右。

{

wait (chopstick[ i]) ;

wait (chopstick[ i + 1 ] mod 5) ;

eat();

signal (chopstick[ i]) ;

signal (chopstick[ i + 1 ] mod 5) ;

}

}

D．利用管程机制实现（最终该实现是失败的，见以下分析）：

原理：不是对每只筷子设置信号量，而是对每个哲学家设置信号量。test()函数有以下作

用：

a. 如果当前处理的哲学家处于饥饿状态且两侧哲学家不在吃饭状态，则当前哲学家通过

test()函数试图进入吃饭状态。

b. 如果通过test()进入吃饭状态不成功，那么当前哲学家就在该信号量阻塞等待，直到

其他的哲学家进程通过test()将该哲学家的状态设置为EATING。

c. 当一个哲学家进程调用put_forks()放下筷子的时候，会通过test()测试它的邻居，

如果邻居处于饥饿状态，且该邻居的邻居不在吃饭状态，则该邻居进入吃饭状态。

由上所述,该算法不会出现死锁，因为一个哲学家只有在两个邻座都不在进餐时，才允

许转换到进餐状态。

该算法会出现某个哲学家适终无法吃饭的情况，即当该哲学家的左右两个哲学家交替

处在吃饭的状态的时候，则该哲学家始终无法进入吃饭的状态，因此不满足题目的要求。

但是该算法能够实现对于任意多位哲学家的情况都能获得最大的并行度，因此具有重要

的意义。

伪码：

#define N 5 /* 哲学家人数*/

#define LEFT (i-1+N)%N /* i的左邻号码 */

#define RIGHT (i+1)%N /* i的右邻号码 */

typedef enum { THINKING, HUNGRY, EATING } phil_state; /*哲学家状态*/

monitor dp /*管程*/

{

phil_state state[N];

semaphore mutex =1;

semaphore s[N]; /*每个哲学家一个信号量，初始值为0*/

void test(int i)

{

if ( state[i] == HUNGRY state[LEFT(i)] != EATING

state[RIGHT(i)] != EATING )

{

state[i] = EATING;

V(s[i]);

}

}

void get_forks(int i)

{

P(mutex);

state[i] = HUNGRY;

test(i); /*试图得到两支筷子*/

V(mutex);

P(s[i]); /*得不到筷子则阻塞*/

}

void put_forks(int i)

{

P(mutex);

state[i]= THINKING;

test(LEFT(i)); /*看左邻是否进餐*/

test(RIGHT(i)); /*看右邻是否进餐*/

V(mutex);

}

}

哲学家进程如下：

void philosopher(int process)

{

while(true)

{

think();

get_forks(process);

eat();

put_forks(process);

}

}

2.理发师问题：一个理发店有一个入口和一个出口。理发店内有一个可站5 位顾客的站席

区、4 个单人沙发、3 个理发师及其专用理发工具、一个收银台。新来的顾客坐在沙发上等

待；没有空沙发时，可在站席区等待；站席区满时，只能在入口外等待。理发师可从事理

发、收银和休息三种活动。理发店的活动满足下列条件：

1）休息的理发师是坐地自己专用的理发椅上，不会占用顾客的沙发；

2）处理休息状态的理发师可为在沙发上等待时间最长的顾客理发；

3）理发时间长短由理发师决定；

4）在站席区等待时间最长的顾客可坐到空闲的理发上；

5）任何时刻最多只能有一个理发师在收银。

试用信号量机制或管程机制实现理发师进程和顾客进程。

原理：

(1)customer 进程：

首先检查站席区是否已满（stand_capacity）,若满选择离开，否则进入站席区，即进入

理发店。在站席区等待沙发的空位（信号量sofa），如果沙发已满，则进入阻塞等待队列，

直到出现空位，在站席区中等待时间最长的顾客离开站席区（stand_capacity）。坐到沙

发上，等待理发椅(barber_chair)，如果理发椅已满，则进入阻塞等待队列，直到出现

空位，在沙发上等待时间最长的顾客离开沙发（释放信号量sofa）。坐到理发椅上，释放

准备好的信号（customer_ready），获得该理发师的编号（0~1 的数字）。等待理发师理

发结束（finished[barber_number]）。在离开理发椅之前付款（payment），等待收据

(receipt)，离开理发椅（leave_barberchair）。最后离开理发店。

这里需要注意几点：

a) 首先是几个需要进行互斥处理的地方，主要包括:进入站席区、进入沙发、进入理发椅

和付款几个地方。

b) 通过barber_chair 保证一个理发椅上最多只有一名顾客。但这也不够，因为单凭

baber_chair 无法保证一名顾客离开理发椅之前，另一位顾客不会坐到该理发椅上，

因此增加信号量leave_barberchair，让顾客离开理发椅后，释放该信号，而理发

师接收到该信号后才释放barber_chair 等待下一位顾客。

c) 在理发的过程中，需要保证是自己理发完毕，才能够进行下面的付款、离开理发椅的活

动。这个机制是通过customer 进程获得给他理发的理发师编号来实现的，这样，当

该编号的理发师释放对应的finished[i]信号的时候，该顾客才理发完毕。

d) 理发师是通过mutex 信号量保证他们每个人同时只进行一项操作（理发或者收款）。

e) 为了保证该顾客理发完毕后马上可以付款离开，就应该保证给该顾客理发的理发师在理

发完毕后马上到收银台进入收款操作而不是给下一位顾客服务。在伪码中由以下机制实

现：即顾客在释放离开理发椅的信号前，发出付款的信号。这样该理发师得不到顾客的

离开理发椅的信号，不能进入下一个循环为下一名顾客服务，而只能进入收款台的收款

操作。直到顾客接到收据后，才释放离开理发椅的信号，离开理发椅，让理发师释放该

理发椅的信号，让下一位等待的顾客坐到理发椅上。

(2)barber 进程

首先将该理发师的编号压入队列，供顾客提取。等待顾客坐到理发椅坐好(信号量

customer_ready)，开始理发，理发结束后释放结束信号（finished[i]）。等待顾客

离开理发椅（leave_barberchair）（期间去收银台进行收款活动），释放理发椅空闲信

号(barber_chair)，等待下一位顾客坐上来。

(3)cash（收银台）进程

等待顾客付款(payment),执行收款操作，收款操作结束，给付收据（receipt）。

信号量总表：

信号量 wait signal

stand_capacity 顾客等待进入理发店 顾客离开站席区

sofa 顾客等待坐到沙发 顾客离开沙发

barber_chair 顾客等待空理发椅 理发师释放空理发椅

customer_ready 理发师等待，直到一个顾客坐

到理发椅

顾客坐到理发椅上，给理发师

发出信号

mutex 等待理发师空闲，执行理发或

收款操作

理发师执行理发或收款结束，

进入空闲状态

mutex1 执行入队或出队等待 入队或出队结束，释放信号

finished[i] 顾客等待对应编号理发师理

发结束

理发师理发结束，释放信号

leave_barberchair 理发师等待顾客离开理发椅 顾客付款完毕得到收据，离开

理发椅释放信号

payment 收银员等待顾客付款 顾客付款，发出信号

receipt 顾客等待收银员收、开具收据收银员收款结束、开具收据，

释放信号

伪码：

semaphore stand_capacity=5;

semaphore sofa=4;

semaphore barber_chair=3;

semaphore customer_ready=0;

semaphore mutex=3;

semaphore mutex1=1;

semaphore finished[3]={0,0,0};

semaphore leave_barberchair=0;

semaphore payment=0;

semaphore receipt=0;

void customer()

{

int barber_number;

wait(stand_capacity); //等待进入理发店

enter_room(); //进入理发店

wait(sofa); //等待沙发

leave_stand_section(); //离开站席区

signal(stand_capacity);

sit_on_sofa(); //坐在沙发上

wait(barber_chair); //等待理发椅

get_up_sofa(); //离开沙发

signal(sofa);

wait(mutex1);

sit_on_barberchair(); //坐到理发椅上

signal(customer_ready);

barber_number=dequeue(); //得到理发师编号

signal(mutex1);

wait(finished[barber_number]); //等待理发结束

pay(); //付款

signal(payment); //付款

wait(receipt); //等待收据

get_up_barberchair(); //离开理发椅

signal(leave_barberchair); //发出离开理发椅信号

exit_shop(); //了离开理发店

}

void barber(int i)

{

while(true)

{

wait(mutex1);

enqueue(i); //将该理发师的编号加入队列

signal(mutex1);

wait(customer_ready); //等待顾客准备好

wait(mutex);

cut_hair(); //理发

signal(mutex);

signal(finished[i]); //理发结束

wait(leave_barberchair); //等待顾客离开理发椅信号

signal(barber_chair); //释放barber_chair 信号

}

}

void cash() //收银

{

while(true)

{

wait(payment); //等待顾客付款

wait(mutex); //原子操作

get_pay(); //接受付款

give_receipt(); //给顾客收据

signal(mutex);

signal(receipt); //收银完毕，释放信号

}

}

分析：

在分析该问题过程中，出现若干问题，是参阅相关资料后才认识到这些问题的隐蔽性和严重

性的,主要包括：

（1）在顾客进程，如果是在释放leave_barberchair 信号之后进行付款动作的话，很

容易造成没有收银员为其收款的情形， 原因是： 为该顾客理发的理发师收到

leave_barberchair 信号后，释放barber_chair 信号，另外一名顾客坐到理发椅上，

该理发师有可能为这另外一名顾客理发，而没有为刚理完发的顾客收款。为解决这个问题，

就是采取在释放leave_barberchair 信号之前，完成付款操作。这样该理发师无法进入

下一轮循环为另外顾客服务，只能到收银台收款。

（2）本算法是通过给理发师编号的方式，当顾客坐到某理发椅上也同时获得理发师的编号，

如此，当该理发师理发结束，释放信号，顾客只有接收到为其理发的理发师的理发结束信号

才会进行付款等操作。这样实现，是为避免这样的错误，即：如果仅用一个finished 信

号量的话，很容易出现别的理发师理发完毕释放了finished 信号，把正在理发的这位顾

客赶去付款,而已经理完发的顾客却被阻塞在理发椅上的情形。当然也可以为顾客进行编

号，让理发师获取他理发的顾客的编号，但这样就会限制顾客的数量，因为finished[]

数组不能是无限的。而为理发师编号，则只需要三个元素即可。

3.参考文献：

左金平 计算机操作系统中哲学家进餐问题探究。

参考教材 操作系统—内核与设计原理

其他网络资源

barber system是什么意思

barber system

理发师系统

设计思想的说明:

打瞌睡的理发师问题是一种同步问题的抽象描述。计算机系统中的每个进程都可以消费或生产某类资源理发师问题java代码，当系统中某一进程使用某一资源时理发师问题java代码，可以看作是消耗，且该进程称为消费者。而当某个进程释放资源时，则它就相当一个生产者。因此此题可看作是n个生产者和1个消费者问题。顾客作为生产者，每到来一个就使计数器count增加1，以便让理发师理发（相当于消费）至最后一个顾客（相当于产品）。并且，第1个到来的顾客应负责唤醒理发师；如果不是第1个到达的顾客，则在有空椅子的情况下坐下等待，否则离开理发店（该消息可由计数器count获得）,所以可以通过一个有界缓冲区把理发师和顾客联系起来通过对信号进行P、V操作来实现有关问题和相关描述。

求五个操作操作系统的经典同步互斥问题

理发师问题：

理发店理有一位理发师、一把理发椅和n把供等候理发的顾客坐的椅子

如果没有顾客，理发师便在理发椅上睡觉

一个顾客到来时，它必须叫醒理发师

如果理发师正在理发时又有顾客来到，则如果有空椅子可坐，就坐下来等待，否则就离开。

解法：

引入3个信号量和一个控制变量：

1)控制变量waiting用来记录等候理发的顾客数，初值均为0;

2)信号量customers用来记录等候理发的顾客数，并用作阻塞理发师进程，初值为0;

3)信号量barbers用来记录正在等候顾客的理发师数，并用作阻塞顾客进程，初值为0;

4)信号量mutex用于互斥，初值为1.

var waiting : integer; /*等候理发的顾客数*/

CHAIRS:integer; /*为顾客准备的椅子数*/

customers, barbers，mutex : semaphore;

customers := 0; barbers := 0; waiting := 0; mutex := 1;

Procedure barber;

begin

while(TRUE); /*理完一人,还有顾客吗?*/

P(cutomers); /*若无顾客,理发师睡眠*/

P(mutex); /*进程互斥*/

waiting := waiting – 1; /*等候顾客数少一个*/

V(barbers); /*理发师去为一个顾客理发*/

V(mutex); /*开放临界区*/

cut-hair( ); /*正在理发*/

end;

procedure customer

begin

P(mutex); /*进程互斥*/

if waiting waiting := waiting+1; /* 等候顾客数加1*/

V(customers); /*必要的话唤醒理发师*/

V(mutex); /*开放临界区*/

P(barbers); /*无理发师, 顾客坐着养神*/

get-haircut( ); /*一个顾客坐下等理发*/

end

V(mutex); /*人满了,走吧!*/

end;

1、有一单向行驶的公路桥，每次只允许一辆汽车通过。当汽车到达桥头时，若桥上无车，便可上桥；否则，需等待，直到桥上的汽车下桥为止。若每一辆汽车为一进程，请用PV操作实现。

解：汽车进程Pi（i＝1,2...）

到达桥头

P（S）

上桥行驶

到达桥另一端

V（S）

信号量S的初值＝1

2、有一只铁笼子，每次只能放入一只动物。猎手向笼中放入老虎，农民向笼中放入猪，动物园等待取笼中的老虎，饭店等待取笼中的猪。试用PV操作写出能同步执行的程序。

解：猎手进程 农民进程 动物园进程 饭店进程

P（S） P（S） P（S1) P（S2)

放入虎 放入猪 买老虎 买猪

V（S1) V（S2) V（S) V（S)

信号量初值：S＝1,S1=0,S2=0

操作系统中的信号量机制PV操作，理发店问题和生产者消费者问题有何区别

没碰到过理发店问题，我看的书里没提这个问题，百度到了下面这个。

不过如果是这个问题的话，跟生产者消费者完全没区别吧……理发师是消费者，顾客是生产者……

要求描述理发师和顾客的行为，因此需要两类进程Barber ()和Customer()分别描述理发师和顾客的行为。理发师和顾客之间是同步的关系，理发师和椅子是临界资源，所以顾客之间是互斥的关系。

引入3个信号量和一个控制变量：

1) 控制变量waiting也用于记录等候的顾客数，实际上是customers的一份拷贝。之所以使用waiting是因为无法读取信号量的当前值，初值均为0。

2)信号量customers用来记录等候理发的顾客数(不包括正在理发的顾客)，并用作阻塞理发师进程，初值为0。

3)信号量barbers用来记录正在等候顾客的理发师数（为0或1），并用作阻塞顾客进程，初值为0。

4)信号量mutex用于互斥，初值为1。

进入理发店的顾客必须先看等候的顾客数，如果少于椅子数（n），他坐下来等，否则他就离开。

PV操作代码如下

int waiting=0 ； //等候理发的顾客数(还没理发的)， 0～n

semaphore customers=0, barbers=0, mutex=1;

barber() {

while(TRUE) //理完一人,还有顾客吗?

{ P(customers); //若无顾客,理发师睡眠

P(mutex); //进程互斥

waiting := waiting – 1; //等候顾客数少一个

V(barbers); //理发师去为一个顾客理发

V(mutex); //开放临界区

cut-hair( ); //正在理发(非临界区操作)

}

}

customer() { //顾客进入理发店

P(mutex); //进程互斥

if (waiting n)

{ //还有空位

waiting := waiting+1; //等候顾客数加1

V(customers); //有顾客了，如果理发师在睡则唤醒

V(mutex); //开放临界区

P(barbers); //无理发师, 顾客坐着养神

get-haircut( ); //一个顾客坐下等待理发/

}

else V(mutex); //顾客已满，离开

}

Linux:睡眠理发师问题(用C语言实现)

/*基于信号量采用多线程技术实现进程同步*/

#include pthread.h

#include stdio.h

#include unistd.h

#include stdlib.h

#include semaphore.h

#include sys/time.h

#include math.h

#define CHAIRS 5 //椅子数

sem_t customers; //等待服务的顾客信号量

sem_t barbers;  //等待顾客的理发师信号量

pthread_mutex_t mutex; //互斥变量

int waiting = 0; //正在等待的顾客数

void *barber(void *arg);

void *customer(void *num);

void cut_hair(void);

double timediff(struct timeval i,struct timeval j);

void seed_random(void);

double flat(void);

double normal(void);

double bursty(void);

int main()

{

   int i;

   seed_random();

   pthread_t barber_t,customer_t;

   int error;

   error=pthread_create(barber_t,NULL,barber,NULL);//创建理发师线程

   if(error!=0) {

      printf("pthread_create is not created.../n");

      return -1;

   }

   while(1) {

      usleep(30000);//等待时间如果小于理发师理发时间则会出现等待者过多,否则不会出现等待者过多的现象

      error=pthread_create(customer_t,NULL,customer,NULL);//创建顾客线程

      if(error!=0) {

         printf("pthread_create is not created.../n");

         return -1;

      }

   }

}

double timediff(struct timeval now,struct timeval earlier)

{

   if(now.tv_sec == earlier.tv_sec)

      return (now.tv_usec - earlier.tv_usec)/1000000.0;

   else

      return (1000000*(now.tv_sec - earlier.tv_sec) + now.tv_usec - earlier.tv_usec)/1000000.0;

}

void *barber(void *arg)

{

   while(1)

   {

      sem_wait(customers);//顾客信号量-1

      pthread_mutex_lock(mutex);

      waiting = waiting -1;

      sem_post(barbers);//

      pthread_mutex_unlock(mutex);

      cut_hair();//理发

   }

}

void cut_hair(void)

{

   printf("  Barber:I am cutting the customer's hair.../n");

   usleep(100000);//理发时间

   printf("  Barber:done./n");

}

void *customer(void *num)

{

   pthread_mutex_lock(mutex);

   if(waitingCHAIRS)

   {

       waiting = waiting + 1;

       sem_post(customers);

       pthread_mutex_unlock(mutex);

       sem_wait(barbers); 

   }

   else

   {

      printf("  Waiter is too much.../n");

      pthread_mutex_unlock(mutex);

   }

   //释放占用的资源

}

void seed_random(void)

{

   struct timeval randtime;

   unsigned short xsub1[3];

   gettimeofday(randtime,(struct timezone *)0);

   xsub1[0] = (ushort)randtime.tv_usec;

   xsub1[1] = (ushort)(randtime.tv_usec  16);

   xsub1[2] = (ushort)(getpid());

   seed48(xsub1);

}

double flat()

{

   return drand48()/5;

}

第二问 加个理发师忙碌数量 用来判断 即可

关于理发师问题java代码和理发师在线问答的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。