经典并发处理问题的多种解法

设Request(i)是进程Pi的请求向量，如果Request(i)[j]=k，表示进程Pi需要K个R(j)类型的资源。当Pi发现资源请求后系统将进行下列步骤

(1)如果Request(i)[j] <= Need[i,j],边转向步骤2),否则认为出错，因为它所请求的资源数已超过它所宣布的最大值。

(2)如果Request(i)[j] <= Available[i,j]，便转向步骤3)，否则，表示尚无足够资源，Pi需等待。

(3)系统试探着把资源分配给进程Pi，并需要修改下面数据结构中的数值；

Available[j] = Available[j] - Request(i)[j];

Allocation[i,j] = Allocation[i,j] + Request(i)[j];

Need[i,j] = Need[i,j] - Request(i)[j];

q->front == q->rear;    //队空
q->front == (q->rear+1)%SIZE;    //队满

void producer()
{
    sem_wait();
    lockf();
    QueueFull();
    Enqueue();
    unlockf();
    sem_post();
}
void customer()
{
    sem_wait();
    lockf();
    QueueEmpty();
    Dequeue();
    unlockf();
    sem_post();
}

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>
 
#define TRUE  1
#define FALSE 0
#define SIZE 11
 
typedef int QueueData;	//定义一个整型变量QueueData，与为基本数据类型定义新的别名方法一样 
 
typedef struct _queue   //队列结构体
{
	int data[SIZE];
	int front;     // 指向队头的下标
	int rear;      // 指向队尾的下标
}Queue;
 
struct data             //信号量结构体
{
	sem_t count;
	Queue q;
};
 
struct data sem;
pthread_mutex_t mutex;	//互斥变量使用特定的数据类型 
int num = 0; 
 
int InitQueue (Queue *q)   // 队列初始化
{
	if (q == NULL)
	{
		return FALSE;
	}
	q->front = 0;
	q->rear  = 0;
	return TRUE;
}
 
int QueueEmpty (Queue *q)      //判断空队情况
{
	if (q == NULL)
	{
		return FALSE;
	}
	return q->front == q->rear;
}
 
int QueueFull (Queue *q)     //判断队满的情况
{
	if (q == NULL)
	{
		return FALSE;
	}
	return q->front == (q->rear+1)%SIZE;
} 
 
int DeQueue (Queue *q, int x)   //出队函数
{
	if (q == NULL)
	{
		return FALSE;
	}
	if (QueueEmpty(q))
	{
		return FALSE;
	}
	q->front = (q->front + 1) % SIZE;
	x = q->data[q->front];
	return TRUE;
}
 
int EnQueue (Queue *q, int x)   //进队函数
{
	if (q == NULL)
	{
		return FALSE;
	}	
	if (QueueFull(q))
	{
		return FALSE;
	}	
	q->rear = (q->rear+1) % SIZE;
	q->data[q->rear] = x;
	return TRUE;
}
 
void *Producer()
{
	int i=0;
	while(i<10)
	{
		i++;
		int time = rand() % 10 + 1;          //随机使程序睡眠0点几秒           
		usleep(time * 100000);
		                                      
		sem_wait(&sem.count);                 //信号量的P操作（使信号量的值减一） 
		pthread_mutex_lock(&mutex);           //互斥锁上锁
		if(!QueueFull(&sem.q))					//若队未满 
		{
			num++;                                
			EnQueue (&sem.q, num);              //消息进队
			printf("生产了一条消息,count=%d\n", num); 
		}                                      
		else	printf("Full\n");                                       
		pthread_mutex_unlock(&mutex);         //互斥锁解锁
		sem_post(&sem.count);                  //信号量的V操作（使信号量的值加一） 
	}
	printf("i(producer)=%d\n",i);
}
 
void *Customer()
{
	int i=0;
	while(i<10)
	{
		i++;
		int time = rand() % 10 + 1;   //随机使程序睡眠0点几秒
		usleep(time * 100000);
		
		sem_wait(&sem.count);           //信号量的P操作
		pthread_mutex_lock(&mutex);    //互斥锁上锁
		
		if(!QueueEmpty(&sem.q))			//若队未空 
		{
			num--;
			DeQueue (&sem.q, num);       //消息出队
			printf("消费了一条消息,count=%d\n",num);
		}
		else	printf("Empty\n");
		pthread_mutex_unlock(&mutex);  //互斥锁解锁
		sem_post(&sem.count);         //信号量的V操作
	}
	printf("i(customer)=%d\n",i);
}
 
int main()
{
	srand((unsigned int)time(NULL));
	
	//信号量地址，信号量在线程间共享，信号量的初始值 
	sem_init(&sem.count, 0, 10);    //信号量初始化（做多容纳10条消息，容纳了10条生产者将不会生产消息）
	
	pthread_mutex_init(&mutex, NULL);  //互斥锁初始化
	
	InitQueue(&(sem.q));   //队列初始化
	
	pthread_t producid;
	pthread_t consumid;
	
	pthread_create(&producid, NULL, Producer, NULL);   //创建生产者线程
	pthread_create(&consumid, NULL, Customer, NULL);   //创建消费者线程
	
	pthread_join(consumid, NULL);    //线程等待，如果没有这一步，主程序会直接结束，导致线程也直接退出。
	
	sem_destroy(&sem.count);         //信号量的销毁 
	
	pthread_mutex_destroy(&mutex);   //互斥锁的销毁
	
	return 0;
}

while(1)
{
    think();
    hungry();
    wait(chopstick[i]);
    wait(chopstick[(i+1)%5]);
    eat();
    signal(chopstick[i]);
    signal(chopstick[(i+1)%5]);
}

 semaphore fork[5];
 for (int i=0;i<5;i++)
     fork[i]= 1;
 semaphore room=4;   //该解法突破了进入临界区的进程容量为1的限制
//增加一个侍者，设想有两个房间1号房间是会议室，2号房间是餐厅
cobegin
   process philosopher_i( ){/*i=0,1,2,3, 4 */
      while(true) {
      think( );
      P(room);  //控制最多允许4位哲学家进入2号房间餐厅取叉子
      P(fork[i]);
      P(fork[(i+1)%5]); 
      eat( );
      V(fork[i]);
      V(fork[(i+1)%5]);
      V(room);
   }
 }
 coend

while (1) {think();hungry();Swait(chopsticks[i],chopsticks[(i+1)%5]);eat();Signal(chopsticks[i],chopsticks[(i+1)%5]);   }