哲学家就餐问题

最新推荐文章于 2019-11-16 18:46:50 发布

油条蘸甜豆浆

最新推荐文章于 2019-11-16 18:46:50 发布

阅读量490

点赞数

分类专栏：多线程文章标签： random null windows linux class each

多线程专栏收录该内容

9 篇文章

订阅专栏

本文介绍了一个哲学家就餐问题的Linux程序实现。通过使用信号量和互斥锁来模拟多个哲学家轮流思考和进餐的过程，避免了死锁的发生。该程序能够清晰地展示哲学家就餐问题的经典解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转自：
http://www.cnblogs.com/zxnblake/archive/2009/05/31/1493081.html

本文是哲学家就餐问题在 linux 上的程序实现，与windows 平台的实现类似，
程序上稍有不同。

PhilosopherDining.cpp
#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>
#include "RasUtil.h"
using namespace std;
const unsigned int PHILOSOPHER_NUM=5;
const char THINKING=1;
const char HUNGRY=2;
const char DINING=3;
// each fork has a semaphore
sem_t semph[PHILOSOPHER_NUM];
// Mutex for printing
pthread_mutex_t mutex;
void* philosopherProc(void* param);
int main(int argc, char* argv[])
{
       int i;
       srand(getpid());
       pthread_t philosopherThread[PHILOSOPHER_NUM];
       int phId[PHILOSOPHER_NUM];
       pthread_mutex_init(&mutex, NULL);
       for (i=0; i<PHILOSOPHER_NUM; i++)
       {
               phId[i] = i;
              sem_init(&semph[i], 0, 1);
              pthread_create(&philosopherThread[i], NULL, philosopherProc, (void*)(&phId[i]));
              usleep(50);
       }
       sleep(3);
       return 0;
}
void* philosopherProc(void* param)
{
       int myid;
       char idStr[128];
       char stateStr[128];
       char mystate;
       int ret;
       unsigned int leftFork;
       unsigned int rightFork;
       myid = *((int*)(param));
       RasUtil::intToStr(myid, idStr);
 
       cout << "philosopher " << myid << " begin......" << endl;
       //usleep(10);
       // initial state is THINKING
       mystate = THINKING;
       leftFork = (myid) % PHILOSOPHER_NUM;
       rightFork = (myid + 1) % PHILOSOPHER_NUM;
       while (true)
       {
              switch(mystate)
              {
              case THINKING:
                     // changing my state
                     mystate = HUNGRY;
                     strcpy(stateStr, "HUNGRY");
                     break;
              case HUNGRY:
                     strcpy(stateStr, "HUNGRY");
                     // first test the left fork ...
                     ret = sem_trywait(&semph[leftFork]);
                     if (ret == 0)
                     {
                            // left fork is ok, take it up !
                            // then test the right fork ...
                            ret = sem_trywait(&semph[rightFork]);
                            if (ret == 0)
                            {
                                   // right fork is also ok !
                                   // changing my state
                                   mystate = DINING;
                                   strcpy(stateStr, "DINING");
                            }
                            else
                            {
                                   // right fork is being used by others, so I must put down
                                   // the left fork.
                                   sem_post(&semph[leftFork]);
                            }
                     }
                     break;
              case DINING:
                     // put down both the left and right fork
                     sem_post(&semph[leftFork]);
                     sem_post(&semph[rightFork]);
                     // changing my state
                     mystate = THINKING;
                     strcpy(stateStr, "THINKING");
                     break;
              }
              // print my state
              pthread_mutex_lock(&mutex);
              cout << "philosopher " << myid << " is : " << stateStr << endl;  
              pthread_mutex_unlock(&mutex);
  
              // sleep a random time : between 1 - 5 s
              int sleepTime; 
              sleepTime = 1 + (int)(5.0*rand()/(RAND_MAX+1.0)); 
              usleep(sleepTime*10);
       }
}
RasUtil.h : 完成整数转换为字符串
#ifndef _RasUtil_h_
#define _RasUtil_h_
class RasUtil
{
public:
       static inline void intToStr(int i, char* str);
};

inline void RasUtil::intToStr(int i, char* str)
{
     int dec;
     int sign;
     char* p;
     p = ecvt(i, 10, &dec, &sign);
     strcpy(str, p);
     str[dec] = 0;
}
#endif