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

• 姓名：江磊
• 学号：201821121059
• 班级：计算1812

1. 选择哪一个问题

• 哲学家进餐问题

2. 给出伪代码

首先筷子是大家公用的资源，当一位哲学家想要进餐时需要同时拿起左右两边的两根筷子，这时就需要对左右两边的筷子进行加锁，这样其他的哲学家就不能使用。当正在进餐的哲学家放下筷子的时候，就相当于给筷子解锁，相邻的两位哲学家才能进餐。

semaphore chopstick[5]={1,1,1,1,1};

do{
    /*当哲学家饥饿时，总是先拿起左边的筷子，再拿起右边的筷子*/
    wait(chopstick[i]);           //拿起左筷子
    wait(chopstick[(i+1)%5]);     //拿起右筷子
    eat();                        //进餐
    signal(chopstick[i]);         
    signal(chopstick[i+1]%5);     
    think();                      
    }while(true);

但是在上述情况中，假如五位哲学家同时饥饿而各自拿起左边的筷子时，那当五名哲学家都再同时拿起右边的筷子时，就会造成死锁，这样程序就运行不下去。

　　　   因此，需要对上述算法进行改进，限制仅当哲学家左右的两只筷子都可用时，才允许他拿起筷子进餐。可以利用AND 型信号量机制实现。

记录型信号量代码：

semaphore mutex = 1; // 这个过程需要判断两根筷子是否可用，并保护起来
semaphore chopstick[5]={1,1,1,1,1};
void philosopher(int i)
{
    while(true)
    {
        /* 这个过程中可能只能由一个人在吃饭，效率低下，有五只筷子，其实是可以达到两个人同时吃饭 */
        think();                   
        wait(mutex);                   
        wait(chopstick[(i+1)%5]);     
        wait(chopstick[i]);             
        signal(mutex);              
        eat();　　　　　　　　　　　　　    　　　　　　　　　　　　　　
        signal(chopstick[(i+1)%5]);     
        signal(chopstick[i]);           
    }
}

AND信号量代码：

semaphore chopstick[5]={1,1,1,1,1};
do{
    think();        //思考
    Swait(chopstick[(i+1)%5],chopstick[i]);   //请求筷子
    eat();           //进餐
    Ssignal(chopstick[(i+1)%5],chopstick[i]); //释放筷子
}while(true);

 

3. 给出完整代码

1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <string.h>
  4 #include <stdint.h>
  5 #include <stdbool.h>
  6 #include <errno.h>
  7 #include <unistd.h>
  8 #include <sys/types.h>
  9 #include <sys/stat.h>
 10 #include <sys/ipc.h>
 11 #include <sys/sem.h>
 12 #include <sys/wait.h>
 13
 14
 15 union semun
 16 {
 17     int val;
 18     struct semid_ds *buf;
 19     unsigned short *array;
 20     struct seminfo *__buf;
 21 };
 22
 23 #define ERR_EXIT(m) \
 24     do { \
 25         perror(m); \
 26         exit(EXIT_FAILURE); \
 27     } while(0)
 28
 29 //申请一个资源
 30 int    wait_1chop(int no,int semid)
 31 {
 32     //资源减1
 33     struct sembuf sb = {no,-1,0};
 34     int ret;
 35     ret = semop(semid,&sb,1);
 36     if(ret < 0) {
 37         ERR_EXIT("semop");
 38     }
 39     return ret;
 40 }
 41
 42 // 释放一个资源
 43 int free_1chop(int no,int semid)
 44 {
 45     //资源加1
 46     struct sembuf sb = {no,1,0};
 47     int ret;
 48     ret = semop(semid,&sb,1);
 49     if(ret < 0) {
 50         ERR_EXIT("semop");
 51     }
 52     return ret;
 53 }
 54
 55 //筷子是一个临界资源
 56 #define DELAY (rand() % 5 + 1)
 57
 58 //相当于P操作
 59 //第一个参数是筷子编号
 60 //第二个参数是信号量编号
 61 void wait_for_2chop(int no,int semid)
 62 {
 63     //哲学家左边的筷子编号和哲学家编号是一样的
 64     int left = no;
 65     //右边的筷子
 66     int right = (no + 1) % 5;
 67
 68     //筷子值是两个
 69     //操作的是两个信号量,即两种资源都满足,才进行操作
 70     struct sembuf buf[2] = {
 71         {left,-1,0},
 72         {right,-1,0}
 73     };
 74     //信号集中有5个信号量，只是对其中的资源sembuf进行操作
 75     semop(semid,buf,2);
 76 }
 77
 78 //相当于V操作  ,释放筷子
 79 void free_2chop(int no,int semid)
 80 {
 81     int left = no;
 82     int right = (no + 1) % 5;
 83     struct sembuf buf[2] = {
 84         {left,1,0},
 85         {right,1,0}
 86     };
 87     semop(semid,buf,2);
 88 }
 89
 90
 91 //哲学家要做的事
 92 void philosophere(int no,int semid)
 93 {
 94     srand(getpid());
 95     for(;;)
 96     {
 97     #if 1
 98         //当两只筷子都可用的时候，哲学家才能进餐
 99         printf("%d号哲学家 思考中\n",no);  //思考中
100         sleep(DELAY);
101         printf("%d号哲学家 饿了\n",no);    //饥饿
102         wait_for_2chop(no,semid); //拿到两只筷子才能吃饭
103         printf("%d号哲学家 正在进餐\n",no);    //进餐
104         sleep(DELAY);
105         free_2chop(no,semid); //释放两只筷子
106     #else
107         //可能会造成死锁
108         int left = no;
109         int right = (no + 1) % 5;
110         printf("%d is thinking\n",no);  //思考中
111         sleep(DELAY);
112         printf("%d is hungry\n",no);    //饥饿
113         wait_1chop(left,semid);         //拿起左筷子（只要有一个资源就申请）
114         sleep(DELAY);
115         wait_1chop(right,semid);        //拿起右筷子
116         printf("%d is eating\n",no);    //进餐
117         sleep(DELAY);
118         free_1chop(left,semid);         //释放左筷子
119         free_1chop(right,semid);          //释放右筷子
120     #endif
121     }
122 }
123
124
125 int main(int argc,char *argv[])
126 {
127     int semid;
128     //创建信号量集，其中有5个信号量
129     semid = semget(IPC_PRIVATE,5,IPC_CREAT | 0666);
130     if(semid < 0) {
131         ERR_EXIT("semid");
132     }
133     union semun su;
134     su.val = 1;
135     int i;
136     for(i = 0;i < 5; ++i) {
137         //第二个参数也是索引
138         semctl(semid,i,SETVAL,su);
139     }
140     //创建4个子进程
141     int num = 0;
142     pid_t pid;
143     for(i = 1;i < 5;++i)
144     {
145        pid = fork();
146        if(pid < 0)
147         {
148            ERR_EXIT("fork");
149         }
150         if(0 == pid)  //子进程
151         {
152             num = i;
153             break;
154         }
155     }
156     //哲学家要做的事情
157    philosophere(num,semid);
158     return 0;
159 }

　　

4. 运行结果并解释

 

 

 结果分析：

 

 以4号哲学家为例子，由于3号哲学家已经在进餐了，所以当4号哲学家饿了的时候并能够马上进行进餐，而是需要等待3号哲学家吃完了才能够拿起左右两个筷子。这样就不会构成死锁。