Sleeping Barber Problem 是一个经典的同步问题，很多人可能都熟悉或至少听说过。
这是基于理发店（一个线程）在等候室中没有客户（每个客户是线程）时休眠的前提（这是一个信号量）。如果有人，他会削减他的头发（象征着一些处理）并且顾客离开。如果，等候室里没有人，那么理发师会去睡觉。当另一位顾客到达时，他必须唤醒理发师。
我使用以下基本想法
实现了这一点 （尽管实际代码在C中，但为了解决问题，我编写了以下伪代码而不太关心语法，仅使用{{ 1}}和sem_wait 1 ，以便更顺畅地阅读）
sem_post然而，现在我将与多个理发师一起实施这个问题，我的头脑卡住了。我去维基百科看看我能找到一些关于它的东西，但我发现的唯一的东西就是这个
多个睡觉的理发师问题更加复杂，需要在等待的顾客中协调几位理发师。
我自己无法解决这个问题 2 。
我的代码需要做哪些更改？我在哪里需要额外的信号量？
1 Semaphore Customers = 0;
Semaphore Barber = 0;
Mutex accessSeats = 1;
int NumberOfFreeSeats = N;
Barber {
while(1) {
sem_wait(Customers); // waits for a customer (sleeps)
sem_wait(accessSeats); // mutex to protect the number of available seats
NumberOfFreeSeats++; // a chair gets free
sem_post(Barber); // bring customer for haircut
sem_post(accessSeats); // release the mutex on the chair
// barber is cutting hair
}
}
Customer {
while(1) {
sem_wait(accessSeats); // protects seats so only 1 thread tries to sit in a chair if that's the case
if(NumberOfFreeSeats > 0) {
NumberOfFreeSeats--; // sitting down
sem_post(Customers); // notify the barber
sem_post(accessSeats); // release the lock
sem_wait(Barber); // wait in the waiting room if barber is busy
// customer is having hair cut
} else {
sem_post(accessSeats); // release the lock
// customer leaves
}
}
}
锁定信号量。 sem_wait()解锁
2 免责声明：虽然我已在programmers.stackexchange中提出此问题，但我没有达到预期的答案，我的问题仍然存在。
答案 0 :(得分：2)
这段代码由我编写，稍微修改一下Breveleri定义的算法，它可以非常有效地模拟 多重睡眠理发 问题。我把它写成了我的操作系统分配的模拟目的。我想从你这边得到一些建议。我正在使用“declarations.h”，“SleepingBarber.c”和“makefile”来获得更好的编码结构。
<强> declaration.h
#include <unistd.h> //Provides API for POSIX(or UNIX) OS for system calls
#include <stdio.h> //Standard I/O Routines
#include <stdlib.h> //For exit() and rand()
#include <pthread.h> //Threading APIs
#include <semaphore.h> //Semaphore APIs
#define MAX_CHAIRS 10 //No. of chairs in waiting room
#define CUT_TIME 1 //Hair Cutting Time 1 second
#define NUM_BARB 2 //No. of barbers
#define MAX_CUST 30 //Maximum no. of customers for simulation
sem_t customers; //Semaphore
sem_t barbers; //Semaphore
sem_t mutex; //Semaphore for providing mutially exclusive access
int numberOfFreeSeats = MAX_CHAIRS; //Counter for Vacant seats in waiting room
int seatPocket[MAX_CHAIRS]; //To exchange pid between customer and barber
int sitHereNext = 0; //Index for next legitimate seat
int serveMeNext = 0; //Index to choose a candidate for cutting hair
static int count = 0; //Counter of No. of customers
void barberThread(void *tmp); //Thread Function
void customerThread(void *tmp); //Thread Function
void wait(); //Randomized delay function
<强> SleepingBarber.c
#include "declarations.h"
int main()
{
pthread_t barber[NUM_BARB],customer[MAX_CUST]; //Thread declaration
int i,status=0;
/*Semaphore initialization*/
sem_init(&customers,0,0);
sem_init(&barbers,0,0);
sem_init(&mutex,0,1);
/*Barber thread initialization*/
printf("!!Barber Shop Opens!!\n");
for(i=0;i<NUM_BARB;i++) //Creation of 2 Barber Threads
{
status=pthread_create(&barber[i],NULL,(void *)barberThread,(void*)&i);
sleep(1);
if(status!=0)
perror("No Barber Present... Sorry!!\n");
}
/*Customer thread initialization*/
for(i=0;i<MAX_CUST;i++) //Creation of Customer Threads
{
status=pthread_create(&customer[i],NULL,(void *)customerThread,(void*)&i);
wait(); //Create customers in random interval
if(status!=0)
perror("No Customers Yet!!!\n");
}
for(i=0;i<MAX_CUST;i++) //Waiting till all customers are dealt with
pthread_join(customer[i],NULL);
printf("!!Barber Shop Closes!!\n");
exit(EXIT_SUCCESS); //Exit abandoning infinite loop of barber thread
}
void customerThread(void *tmp) /*Customer Process*/
{
int mySeat, B;
sem_wait(&mutex); //Lock mutex to protect seat changes
count++; //Arrival of customer
printf("Customer-%d[Id:%d] Entered Shop. ",count,pthread_self());
if(numberOfFreeSeats > 0)
{
--numberOfFreeSeats; //Sit on chairs on waiting room
printf("Customer-%d Sits In Waiting Room.\n",count);
sitHereNext = (++sitHereNext) % MAX_CHAIRS; //Choose a vacant chair to sit
mySeat = sitHereNext;
seatPocket[mySeat] = count;
sem_post(&mutex); //Release the seat change mutex
sem_post(&barbers); //Wake up one barber
sem_wait(&customers); //Join queue of sleeping customers
sem_wait(&mutex); //Lock mutex to protect seat changes
B = seatPocket[mySeat]; //Barber replaces customer PID with his own PID
numberOfFreeSeats++; //Stand Up and Go to Barber Room
sem_post(&mutex); //Release the seat change mutex
/*Customer is having hair cut by barber 'B'*/
}
else
{
sem_post(&mutex); //Release the mutex and customer leaves without haircut
printf("Customer-%d Finds No Seat & Leaves.\n",count);
}
pthread_exit(0);
}
void barberThread(void *tmp) /*Barber Process*/
{
int index = *(int *)(tmp);
int myNext, C;
printf("Barber-%d[Id:%d] Joins Shop. ",index,pthread_self());
while(1) /*Infinite loop*/
{
printf("Barber-%d Gone To Sleep.\n",index);
sem_wait(&barbers); //Join queue of sleeping barbers
sem_wait(&mutex); //Lock mutex to protect seat changes
serveMeNext = (++serveMeNext) % MAX_CHAIRS; //Select next customer
myNext = serveMeNext;
C = seatPocket[myNext]; //Get selected customer's PID
seatPocket[myNext] = pthread_self(); //Leave own PID for customer
sem_post(&mutex);
sem_post(&customers); //Call selected customer
/*Barber is cutting hair of customer 'C'*/
printf("Barber-%d Wakes Up & Is Cutting Hair Of Customer-%d.\n",index,C);
sleep(CUT_TIME);
printf("Barber-%d Finishes. ",index);
}
}
void wait() /*Generates random number between 50000 to 250000*/
{
int x = rand() % (250000 - 50000 + 1) + 50000;
srand(time(NULL));
usleep(x); //usleep halts execution in specified miliseconds
}
<强>生成文件
all: SleepingBarber
SleepingBarber: SleepingBarber.o
gcc -pthread -o SleepingBarber SleepingBarber.o
SleepingBarber.o: SleepingBarber.c declarations.h
gcc -c SleepingBarber.c
clean:
rm -f *.o SleepingBarber