philo.c

用pthread实现哲学家问题

#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <semaphore.h>
#include <mqueue.h>

/* defines */
#define NUM_PHILO				5

#define USE_SEMPHORE			0

#define THINK_TIME 				2
#define EAT_TIME 					1

#define BUFFER 40

//#undef	 printf
//#define printf printk

/* locals */
static sem_t sem_id[NUM_PHILO];
static mqd_t msgQ_id[NUM_PHILO];
static sem_t room_sem;

/* function prototype */
void philoSemRoutine(unsigned32);
void philoMsgQRoutine(unsigned32);

void main(void)
{
	/* Add your code here. */
	int ret, i;
	pthread_t             threads[NUM_PHILO];
		
	if(ret = sem_init (&room_sem,0,4))
	{
		printf("sem for romm create failed\n");
		return;
	}
	
	
	if(USE_SEMPHORE)
	{	
		for (i=0; i<NUM_PHILO;i++)
		{
			char semName[20];	
			sem_t *semTemp;
			memset(semName,0,sizeof(semName));					
			sprintf (semName,"%s%d","semB_",i);
			semTemp = &sem_id[i];
			
			semTemp = sem_open(semName,O_CREAT,0777,1);
			
			if( semTemp == SEM_FAILED ) 
			{
				printf("sem_open error!!\n");
				return ;
			}
					
			ret = pthread_create(&threads[i], NULL, philoSemRoutine, i);
			if(ret != 0)
			{
				printf("pthread create failed\n");
				return;
			}
		}
	}
	else 
	{

		
			
		for (i=0; i<1;i++)
		{
			char msgQName[20];
			char msgBuf[10] = "FORK OK";
			
			struct mq_attr attr;
			
			memset(msgQName,0,sizeof(msgQName));
			
			sprintf (msgQName,"msgQ_%d",i);
			
			attr.mq_msgsize = BUFFER;
			attr.mq_maxmsg = BUFFER;
				
			msgQ_id[i] = mq_open(msgQName, O_CREAT , &attr);		

			if (msgQ_id[i] == (mqd_t)-1) 
			{
				printf("message create failed!!\n");
				return;
			}
			else
			{
				printf("message create success!!\n");
			}
			
			ret = mq_send(msgQ_id[i], msgBuf, strlen(msgBuf), 1);
			if(ret != 0)
			{
				printf("message send failed!!\n");
				return;
			}
			else
			{
				printf("message send success!!\n");
			}
			
			
			ret = pthread_create(&threads[i], NULL, philoMsgQRoutine, i);
			if(ret != 0)
			{
				printf("pthread create failed\n");
				return;
//			}
		}
		
		
	}

}


void philoSemRoutine(unsigned32 tag)
{
	int lfork, rfork, i;

	i = tag;
	lfork = i;
	rfork = (i + 1) % 5;
		
	printf("\n***philosopher %i begin to think and eat***\n",i);
	
	while(1)
	{
		printf("================++++++++++++++++++++++++\n");
		sem_wait(&room_sem);
		printf("Philosopher %i Enter Room!\n", i);
		
		sem_wait(&sem_id[lfork]);
		printf("Philosopher %i get left fork!\n", i);
		
		sem_wait(&sem_id[rfork]);
		printf("Philosopher %i get right fork!\n", i);
		
		printf("Philosopher %i Eating\n", i);
		
		sleep(EAT_TIME);
		
		sem_post(&sem_id[rfork]);
		printf("================Philosopher %i give up lfork\n", i);
		
		sem_post(&sem_id[lfork]);
		printf("================Philosopher %i give up rfork\n", i);
		
		sem_post(&room_sem);
		printf("===============Philosopher %i Leave Room\n", i);
		
		sleep(THINK_TIME);		
		
	}
}

void philoMsgQRoutine(unsigned32 tag)
{
	int lfork, rfork, i, ret;
	char msgBufOut[10] = "FORK OK";
	char msgBufIn[10];
	int rvprio;
	
	i = tag;
	lfork = i;
	rfork = (i + 1) % 5;
	rvprio = 1;
	
	printf("\n***philosopher %i begin to think and eat***\n",i);
	
	while(1)
	{
		sem_wait(&room_sem);
		printf("Philosopher %i Enter Room!\n", i);
			
		ret = mq_receive(msgQ_id[lfork], msgBufIn, BUFFER, &rvprio);
		if(ret !=0)
		{
			printf("message Q_id[%d] receive failed!!\n", i);
			return;
		}
		printf("Philosopher %i get left fork!\n", i);
		
		ret = mq_receive(msgQ_id[rfork], msgBufIn, BUFFER, &rvprio);
		if(ret !=0)
		{
			printf("message Q_id[%d] receive failed!!\n", i);
			return;
		}
		printf("Philosopher %i get right fork!\n", i);
		
		printf("Philosopher %i Eating\n", i);
		
		sleep(EAT_TIME);
		
		printf("Philosopher %i Leave Room\n", i);
		
		ret = mq_send(msgQ_id[lfork], msgBufOut, strlen(msgBufOut), 1);
		if(ret !=0)
		{
			printf("message Q_id[%d] send failed!!\n", i);
			return;
		}
		
		ret = mq_send(msgQ_id[rfork], msgBufOut, strlen(msgBufOut), 1);
		if(ret !=0)
		{
			printf("message Q_id[%d] send failed!!\n", i);
			return;
		}
		
		sem_post(&room_sem);
		
		sleep(THINK_TIME);
	}
}