Linux IPC实践(12) --System V信号量(2)

实践1:信号量实现进程互斥

父子进程执行流程如下:

父进程	子进程
P	P
O(print)	X(print)
sleep	sleep
O(print)	X(print)
V	V
sleep	sleep

从图中可以看出, O或X总是成对出现的, 要么两个O, 要么两个X;

[cpp]  view plain copy

1. /**P,V原语实现父子进程互斥使用终端**/  
2. // 程序代码  
3. int main(int argc,char *argv[])  
4. {  
5.     int semid = sem_create(IPC_PRIVATE);  
6.     sem_setval(semid, 1);  
7.     int count = 10;  
8.   
9.     pid_t pid = fork();  
10.     if (pid == -1)  
11.         err_exit("fork error");  
12.     else if (pid > 0)   //子进程  
13.     {  
14.         srand(getpid());  
15.         while (count --)  
16.         {  
17.             sem_P(semid);  
18.             //临界区开始  
19.             cout << 'X';  
20.             fflush(stdout); //一定要加上ffflush, 因为中断是行缓冲的  
21.             sleep(rand()%3);  
22.             cout << 'X';  
23.             fflush(stdout);  
24.             //临界区结束  
25.             sem_V(semid);  
26.             sleep(rand()%3);  
27.         }  
28.     }  
29.     else                //父进程  
30.     {  
31.         srand(getpid());  
32.         while (count --)  
33.         {  
34.             sem_P(semid);  
35.             //临界区开始  
36.             cout << 'O';  
37.             fflush(stdout);  
38.             sleep(rand()%3);  
39.             cout << 'O';  
40.             fflush(stdout);  
41.             //临界区结束  
42.             sem_V(semid);  
43.             sleep(rand()%3);  
44.         }  
45.         wait(NULL);  
46.         sem_delete(semid);  
47.     }  
48.   
49.     return 0;  
50. }  

实践2: 信号量集解决哲学家进餐问题

   假设有五位哲学家围坐在一张圆形餐桌旁，做以下两件事情之一：吃饭，或者思考。吃东西的时候，他们就停止思考，思考的时候也停止吃东西。每两个哲学家之间有一只餐叉。因为用一只餐叉很难吃饭，所以假设哲学家必须用两只餐叉吃东西, 而且他们只能使用自己左右手边的那两只餐叉。

[cpp]  view plain copy

1. /**  
2. 解决的方法采用的是: 只有左右两个刀叉都能够使用时,才拿起两个刀叉 
3. 实现了有死锁和无死锁的两种形式的wait_2fork(见下) 
4. **/  
5.   
6. int semid;  
7. //没有死锁的wait  
8. void wait_2fork(unsigned short no)  
9. {  
10.     unsigned short left = no;  
11.     unsigned short right = (no+1)%5;  
12.     struct sembuf sops[2] = {{left, -1, 0}, {right, -1, 0}};  
13.     //同时获取左右两把刀叉  
14.     if (semop(semid, sops, 2) == -1)  
15.         err_exit("wait_2fork error");  
16. }  
17. /* 
18. //有死锁的wait 
19. void wait_2fork(unsigned short no) 
20. { 
21.     unsigned short left = no; 
22.     unsigned short right = (no+1)%5; 
23.     struct sembuf sops = {left, -1, 0}; 
24.     //获取左边的刀叉 
25.     if (semop(semid, &sops, 1) == -1) 
26.         err_exit("wait_2fork error"); 
27.     sleep(4);   //沉睡几秒, 加速死锁的产生 
28.     sops.sem_num = right; 
29.     //获取右边的刀叉 
30.     if (semop(semid, &sops, 1) == -1) 
31.         err_exit("wait_2fork error"); 
32. } 
33. */  
34. //释放两把刀叉  
35. void signal_2fork(unsigned short no)  
36. {  
37.     unsigned short left = no;  
38.     unsigned short right = (no+1)%5;  
39.     struct sembuf sops[2] = {{left, 1, 0}, {right, 1, 0}};  
40.     if (semop(semid, sops, 2) == -1)  
41.         err_exit("signal_2fork error");  
42. }  
43. //哲学家  
44. void philosopher(unsigned short no)  
45. {  
46.     srand(time(NULL));  
47.     while (true)  
48.     {  
49.         cout << no << " is thinking" << endl;  
50.         sleep(rand()%5+1);  
51.         cout << no << " is hunger" << endl;  
52.         wait_2fork(no); //获取两把刀叉  
53.         //进餐  
54.         cout << "++ " << no << " is eating" << endl;  
55.         sleep(rand()%5+1);  
56.         signal_2fork(no);//释放两把刀叉  
57.     }  
58. }  

[cpp]  view plain copy

1. int main()  
2. {  
3.     // 创建一个信号量集: 里面包含5个信号量  
4.     semid = semget(IPC_PRIVATE, 5, IPC_CREAT|0666);  
5.     if (semid == -1)  
6.         err_exit("semget error");  
7.   
8.     //将每个信号量都设初值为1  
9.     union semun su;  
10.     su.val = 1;  
11.     for (int i = 0; i < 5; ++i)  
12.         if (semctl(semid, i, SETVAL, su) == -1)  
13.             err_exit("semctl SETVAL error");  
14.   
15.     //创建四个子进程, 将每个进程的编号设定为no  
16.     pid_t pid;  
17.     unsigned short no = 0;  
18.     for (unsigned short i = 0; i < 4; ++i)  
19.     {  
20.         pid = fork();  
21.         if (pid == -1)  
22.             err_exit("fork error");  
23.         else if (pid == 0)  
24.         {  
25.             no = i+1;  
26.             break;  
27.         }  
28.     }  
29.   
30.     // 最后五个进程(4个子进程+1个父进程)都会汇集到此处,  
31.     // 每个进程代表着一个哲学家,编号no: 0~4  
32.     philosopher(no);  
33.   
34.     return 0;  
35. }