操作系统第6次实验报告：使用信号量解决进程互斥访问

• 姓名：吴永锋
• 学号：201821121051
• 班级：计算1812

1. 选择哪一个问题

哲学家进餐问题：

有五个哲学家围坐在一张圆桌旁就餐，，圆桌上有五个碗和五只筷子，他们的生活方式就是交替地进行思考和进餐。平时每个哲学家独立思考问题，饥饿时便试图分别取其左右两侧的筷子，只有两只筷子都拿到后才能进餐；进餐完毕后应立即放下筷子，然后继续思考问题。

2. 给出伪代码

由问题描述可知，哲学家共享的五只筷子是临界资源，为实现筷子的互斥使用，可为每只筷子设置一个互斥信号量，初值为1，使用一个信号量数组来表示。为描述方便，对每个哲学家进行编号：0~4；五只筷子及其对应的信号量编号也是0~4，且与哲学家编号相同的筷子位于该哲学家左侧。一种简单的解决思路是每个哲学家都先取其左侧的筷子，成功后再取其右侧的筷子，取到两只筷子后就进餐；进餐完毕后再一次释放着两只筷子。

semaphore chop[5];
void main(){
    chop[5]={1,1,1,1,1};
    parbegin(Philosopher(i)(i=0...4));
}

void Philosopher(i){
    do{
        thinking;
        wait(chop[i]);
        wait(chop[i+1]mod5);
        eating;
        signal(chop[i]);
        signal)chop[i+1]mod5);
       }while(1);
}

如果五个哲学家同时成功取到左边的筷子，之后再取右边的筷子时都会失败。五个哲学家都等待右侧筷子而不能吃饭，且都不能释放已取到的左边的筷子，进入死锁状态。

为了避免死锁，我们规定：仅当哲学家左右两侧的筷子都可用时，才允许他一次性同时拿起两只筷子。

semaphore chop[5]; 
void main(){
    chop[5]={1，1，1，1，1}; 
    parbegin(Philosopher(i)(i=0...4));
}

void Philosopher(i) 
{ 
    do { 
        thinking; 
        Swait(chopstick[(i+1)]mod5,chop[i]); 
        eating; 
        Ssignal(chopstick[(i+1)]mod5,chop[i]); 
    }while(1);
} 

3. 给出完整代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>
#include <errno.h>
 
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/wait.h>
 
 
union semun
{
    int val;
    struct semid_ds *buf;
    unsigned short *array;
    struct seminfo *__buf;
};
 
 
#define ERR_EXIT(m) \
    do { \
        perror(m); \
        exit(EXIT_FAILURE); \
    } while(0)
     
 
//申请一个资源
int    wait_1fork(int no,int semid)
{
    //int left = no;
    //int right = (no + 1) % 5;
    struct sembuf sb = {no,-1,0};
    int ret;
    ret = semop(semid,&sb,1);
    if(ret < 0) {
        ERR_EXIT("semop");
    }
    return ret;
}
 
// 释放一个资源
int free_1fork(int no,int semid)
{
    struct sembuf sb = {no,1,0};
    int ret;
    ret = semop(semid,&sb,1);
    if(ret < 0) {
        ERR_EXIT("semop");
    }
    return ret;
}
 
//这里表明叉子是一个临界资源
 
#define DELAY (rand() % 5 + 1)
 
//相当于P操作
void wait_for_2fork(int no,int semid)
{
    //哲学家左边的刀叉编号和哲学家是一样的
    int left = no;
    //右边的刀叉
    int right = (no + 1) % 5;
 
    //刀叉值是两个
    //注意第一个参数是编号
    //操作的是两个信号量,即两种资源都满足,才进行操作
    struct sembuf buf[2] = {
        {left,-1,0},
        {right,-1,0}
    };
    //信号集中有5个信号量，只是对其中的资源sembuf进行操作
    semop(semid,buf,2);
}
 
//相当于V操作  ,释放刀叉
void free_2fork(int no,int semid)
{
    int left = no;
    int right = (no + 1) % 5;
    struct sembuf buf[2] = {
        {left,1,0},
        {right,1,0}
    };
    semop(semid,buf,2);
}
 
 
//哲学家要做的事
void philosophere(int no,int semid)
{
    srand(getpid());
    //srand(time(NULL));
    for(;;) 
    {
    #if 1
        //这里采取的措施是当两把刀叉都可用的时候(即两种资源都满足的时候)
        //哲学家才能吃饭，这样不相邻的哲学家就可吃上饭
        printf("%d is thinking\n",no);  // 思考中
        sleep(DELAY);
        printf("%d is hungry\n",no);  // 感觉到饥饿
        wait_for_2fork(no,semid);//拿到两把叉子才能吃饭
        printf("%d is eating\n",no);  // 吃饭
        sleep(DELAY);
        free_2fork(no,semid);//释放两把叉子
    #else
        //这段代码可能会造成死锁
        int left = no;
        int right = (no + 1) % 5;
        printf("%d is thinking\n",no);  // 思考中
        sleep(DELAY); 
        printf("%d is hungry\n",no);   // 感觉到饥饿
        wait_1fork(left,semid);    // 拿起左叉子,现在是只要有一个资源,就申请
        sleep(DELAY);            
        wait_1fork(right,semid);   // 拿到右叉子
        printf("%d is eating\n",no);  // 吃饭
        sleep(DELAY);
        free_1fork(left,semid); // 释放左叉子
        free_1fork(right,semid);  // 释放右叉子
    #endif
    }
}
 
 
int main(int argc,char *argv[])
{
    int semid;
    //创建信号量
     //信号量集中5个信号量
    semid = semget(IPC_PRIVATE,5,IPC_CREAT | 0666); 
    if(semid < 0) {
        ERR_EXIT("semid");
    }
    union semun su;
    su.val = 1;
    int i;
    for(i = 0;i < 5;++i) {
        //注意第二个参数也是索引
        semctl(semid,i,SETVAL,su);
    }
    //创建4个子进程
    int num = 0;
    pid_t pid;
    for(i = 1;i < 5;++i) 
    {
       pid = fork(); 
       if(pid < 0) 
        {
           ERR_EXIT("fork");
        }
        if(0 == pid)  // 子进程
        {
            num = i;
            break;
        }
    }
    //这里就是哲学家要做的事情
   philosophere(num,semid);
    return 0;
}

4. 运行结果并解释

运行后，不会停止，说明不出现死锁。

选取部分结果分析：

五个哲学家的编号为0~4。

1-5行：一开始，所有哲学家都处于思考状态。

6-7行：0号哲学家饥饿，此时其左右两边的筷子均可用，于是0号哲学家开始进餐。

8行：1号哲学家饥饿，但由于0号哲学家拿走了其右手边的筷子并且没有释放，于是1号哲学家保持饥饿状态。

9行：4号哲学家饥饿，但由于0号哲学家拿走了其左手边的筷子并且没有释放，于是4号哲学家保持饥饿状态。

10-11行：3号哲学家饥饿，此时其左右两边的筷子均可用，于是3号哲学家开始进餐。

12行：2号哲学家饥饿，但由于3号哲学家拿走了其左手边的筷子并且没有释放，于是2号哲学家保持饥饿状态。

13行：0号哲学家进入思考，释放左右两边的筷子。

14行：1号哲学家右手边的筷子被0号哲学家释放，此时1号哲学家左右两边的筷子均可用，于是1号哲学家开始进餐。

15行：3号哲学家进入思考，释放左右两边的筷子。

16行：4号哲学家左手边的筷子被0号哲学家释放，右手边的筷子被3号哲学家释放，此时4号哲学家左右两边的筷子均可用，于是4号哲学家开始进餐。

……

从中可以发现同时最多只能有两个哲学家一起用餐，也不会出现相邻哲学家一起用餐的情况。

参考博客：

https://blog.csdn.net/u014304293/article/details/46004677

https://blog.csdn.net/x1114832836/article/details/90670334