哲学家问题LINUX实现

合集下载

操作系统课程设计——哲学家进餐问题

操作系统课程设计——哲学家进餐问题1000字哲学家进餐问题是一个经典的多线程同步问题，在操作系统中有着广泛的应用。

因此，在操作系统课程设计中，探究哲学家进餐问题是一件非常有意义的事情。

哲学家进餐问题的场景是：五个哲学家围坐在一张圆桌前，每个哲学家的左右两侧有一只筷子，他们需要利用这两只筷子才能进餐。

每个哲学家有两种状态：思考和进餐。

当一个哲学家处于进餐状态时，他需要同时获取他左右两侧的筷子，进餐结束后，他会释放这两只筷子，进入思考状态。

在这个场景中，如果所有的哲学家都同时想要进餐，那么就可能会出现死锁情况，即所有的哲学家都拿到了左手边的筷子，但都无法拿到右手边的筷子，导致无法进餐。

因此，需要在代码中实现同步互斥机制，避免死锁的发生。

本课程设计中，我使用了Java语言来实现哲学家进餐问题。

在代码实现中，首先定义了哲学家、筷子、餐桌等对象，然后使用线程来模拟哲学家的思考和进餐过程。

为了避免死锁，我使用了Chandy/Misra算法，即每个哲学家先尝试去取左手边的筷子，如果取不到就不再继续等待，而是重新回到思考状态，等待下一个机会。

同时，当一个哲学家取到了左手边的筷子之后，如果发现右手边的筷子已被占用，他就会释放左手边的筷子，重新回到思考状态，等待下一个机会。

在实现过程中，我还使用了信号量机制，保证了线程间的同步互斥。

每个筷子都是一个二元信号量，初始为1，表示可用。

当一个哲学家拿起筷子时，他会将对应的信号量减1，表示不可用。

当哲学家用完筷子之后，会将对应的信号量加1，表示可用。

通过这种方式，实现了对筷子的访问同步。

最后，我对代码进行了测试，模拟了多位哲学家同时进行进餐的过程。

在测试中，我发现哲学家进餐的速度受到筷子的数量和哲学家思考进餐比例的影响。

当筷子数量少于哲学家数量时，容易出现死锁；当哲学家思考和进餐的时间相当时，程序的运行情况比较稳定。

总的来说，本课程设计实现了哲学家进餐问题，通过学习该问题，我更深入地理解了同步互斥机制的重要性，并学会了如何使用信号量来实现同步互斥。

哲学家问题解决死锁的方法(一)

哲学家问题解决死锁的方法(一)哲学家问题解决死锁引言哲学家问题是一个典型的并发编程问题，它涉及到五位哲学家围坐在一张圆桌旁，每人面前有一盘饭和一只叉子。

哲学家的生活有两种状态：思考和进餐。

每个哲学家进餐时需要两只叉子，但是一次只能拿起一只，在他左右两边的哲学家也需要使用叉子。

这个问题的挑战在于如何避免死锁的发生。

方法一：使用死锁避免算法使用死锁避免算法是一种解决哲学家问题的常见方法。

该算法的基本思想是通过限制某些哲学家的进餐行为，以避免产生死锁。

1.限制偶数编号的哲学家先拿左手边的叉子，再拿右手边的叉子。

2.限制奇数编号的哲学家先拿右手边的叉子，再拿左手边的叉子。

3.对于哲学家的进餐过程，需要先检查叉子的可用性，如果叉子被其他哲学家使用，则等待。

方法二：使用资源分级策略资源分级策略是另一种解决哲学家问题的方法，它通过划分资源的优先级来避免死锁的发生。

1.将五只叉子按照优先级从高到低排序。

2.每个哲学家在进餐前需要先请求相应优先级的叉子。

3.偶数编号的哲学家优先请求左手边的叉子，再请求右手边的叉子。

4.奇数编号的哲学家优先请求右手边的叉子，再请求左手边的叉子。

方法三：使用资源分配策略资源分配策略是一种更加灵活的解决哲学家问题的方法，它通过动态分配资源来避免死锁。

1.创建一个共享的资源管理器，用于管理叉子的分配和释放。

2.每个哲学家在进餐前向资源管理器请求两只叉子。

3.资源管理器根据当前可用的叉子数量进行分配。

4.当一个哲学家进餐结束后，释放叉子，并通知资源管理器。

结论哲学家问题是一个复杂的并发编程问题，需要谨慎设计解决方案以避免死锁的发生。

通过使用死锁避免算法、资源分级策略和资源分配策略等方法，可以有效地解决哲学家问题，并保证系统的稳定性和高效性。

在实际应用中，可以根据具体需求选择适合的方法来解决死锁问题。

关于哲学家就餐问题的分析代码.

关于哲学家就餐问题的分析代码.①总体思路: 都去拿左边的筷⼦,并且最后⼀个⼈不能去拿筷⼦(防⽌⼤家都拿了左边的筷⼦,没有右边的筷⼦,导致死锁了),解决死锁问题的办法就是同时只允许四位哲学家同时拿起同⼀边的筷⼦，这样就能保证⼀定会有⼀位哲学家能够拿起两根筷⼦完成进⾷并释放资源，供其他哲学家使⽤，从⽽实现永动，避免了死锁。

举个最简单的栗⼦，假定0~3号哲学家已经拿起了他左边的筷⼦，然后当4号哲学家企图去拿他左边的筷⼦的时候，将该哲学家的线程锁住，使其拿不到其左边的筷⼦，然后其左边的筷⼦就可以被3号哲学家拿到，然后3号哲学家进餐，释放筷⼦，然后更多的哲学家拿到筷⼦并进餐。

如何才能实现当4号哲学家企图拿起其左边的筷⼦的时候将该哲学家的线程阻塞？这个时候就要⽤到该问题的提出者迪杰斯特拉（这货还提出了迪杰斯特拉最短路径算法，著名的银⾏家算法也是他发明的）提出的信号量机制。

因为同时只允许有四位哲学家同时拿起左筷⼦，因此我们可以设置⼀个信号量r，使其初始值为4，然后每当⼀位哲学家企图去拿起他左边的筷⼦的时候，先对信号量做⼀次P操作，从⽽当第五位哲学家企图去拿做筷⼦的时候，对r做⼀次P操作，r = -1，由r < 0得第五位哲学家的线程被阻塞，从⽽不能拿起左筷⼦，因此也就避免了死锁问题。

然后当哲学家放下他左边的筷⼦的时候，就对r做⼀次V操作。

* @author 王有康* @data 2019、7、31* @version V1.1* @Last Modified 2018/10/25 wangyoukang* @note 当前版本是v1.1版本，以后需要修改，可以在上添加版本和修改⽇期* @note* @warning* @Function List :************************************/#include <stdio.h>#include <stdlib.h>#include <malloc.h>#include <time.h>#include <unistd.h>#include <pthread.h>#include <semaphore.h>#define N 5//互斥锁pthread_mutex_t chops[N];//信号量sem_t r;/*********************** @fn philosopher* @biref 每次只有4个⼈能够获得左⼿资源，这样不会死锁* @param philosopher number* @return* @other***********************/void philosopher(void *arg){int i = *(int *)arg;int left = i;int right = (i + 1)%N;while(1){printf("哲学家%d在思考问题\n",i);usleep(1000);printf("哲学家%d饿了\n",i);sem_wait(&r);pthread_mutex_lock(&chops[left]);printf("philosopher %d take left lock\n",i);pthread_mutex_lock(&chops[right]);printf("philosopher %d take right lock\n",i);printf("philosopher %d eat\n",i);usleep(1000);pthread_mutex_unlock(&chops[right]);printf("philosopher %d release right lock\n",i);pthread_mutex_unlock(&chops[left]);printf("philosopher %d realease left lock\n",i);sem_post(&r);}}/*********************** @fn philosopher* @biref 主函数* @param* @return* @other***********************/int main(int argc,char **argv){int i = 0,*ptr;pthread_t tid[N];for(i = 0;i < N;i++){pthread_mutex_init(&chops[i],NULL);}sem_init(&r,0,4);for(i = 0;i < N;i++){//防⽌主线程和对等线程竞争，给线程和主线程分配不同的内存区域。

操作系统课程设计项目参考

滴加碘液后
滴加碘液前
12/12/2021
第十二页，共二十三页。
消化(xiāohuà)：在消化道内将食物分解成可吸收 (xīshōu)的成分的过程
（包括物理性消化和化学性消化）
吸收(xīshōu)：营养物质通过消化道壁进入循环系统的过程
12/12/2021
第十三页，共二十三页。
消化(xiāohuà)和吸收的过程
12/12/2021
第十九页，共二十三页。
练习(liànxí)
• 2、分析数据，指出(zhǐ chū)哪一部分消化道中消化液最多。
• 在每天摄入800克食物和1200毫升水的情况下，消化腺大致分泌以下数量消化液。 1500毫升唾液 2000毫升胃液 1500毫升肠液 500毫升胆汁 1500毫升胰液
12/12/2021
第二十二页，共二十三页。
内容总结 (nèiróng)
第二节。食物中的营养物质是在消化系统中被消化和吸收的。这粒西瓜籽在姗姗的消化道内，经过了难忘的时光。它先遇到像轧钢机似的上、下尖硬的怪物，差点儿将它压得粉身碎骨。后来它
No 钻进了一条(yī tiáo)又长又窄的迷宫，它在这里走了很久，身边的许多物质都神秘地消失了。走出迷
唾液腺、胃腺(wèixiàn)、肝脏、胰腺、肠腺
1、淀粉在__口__腔__开始消化、蛋白质在____开始胃消化、脂肪在_______开始消小化肠。
2、胆汁是一种消化液，但不含消化酶，起乳化脂肪的作用。
二、人体消化、吸收的主要器官—— _____小肠能训练解
胰脏：分泌(fēnmì)胰液肠腺：分泌肠液
肝脏：最大的腺体，分泌胆汁。胆汁无消化酶，有乳化脂肪的
作用。
第七页，共二十三页。

linuxc语言哲学家进餐---信号量PV方法一

linuxc语⾔哲学家进餐---信号量PV⽅法⼀1、实验原理由Dijkstra提出并解决的哲学家进餐问题(The Dinning Philosophers Problem)是典型的同步问题。

该问题是描述有五个哲学家共⽤⼀张圆桌，分别坐在周围的五张椅⼦上，在圆桌上有五个碗和五只筷⼦，他们的⽣活⽅式是交替地进⾏思考和进餐。

平时，⼀个哲学家进⾏思考，饥饿时便试图取⽤其左右最靠近他的筷⼦，只有在他拿到两只筷⼦时才能进餐。

进餐完毕，放下筷⼦继续思考。

2.实验内容：显⽰出每个哲学家的⼯作状态，如吃饭，思考。

连续运⾏30次以上都未出现死锁现象。

3.分析解决⽅案⼀：现在引⼊问题的关键：这些哲学家很穷，只买得起五根筷⼦。

他们坐成⼀圈，两个⼈的中间放⼀根筷⼦。

哲学家吃饭的时候必须同时得到左⼿边和右⼿边的筷⼦。

如果他⾝边的任何⼀位正在使⽤筷⼦，那他只有等着。

所以我们就假设最多只有4民哲学家在进餐这样就能保证没有死锁的情况。

代码如下：1 #include<unistd.h>2#define NUM 53int ID[NUM]={0,1,2,3,4};4 sem_t sem_chopsticks[NUM];5 sem_t sem_eaters;6int eaters_num=0;//记录已经吃过饭的次数78//初始化信号量函数9void sem_signal_init(){10int i;11for(i=0;i<NUM;i++){12if(sem_init(&sem_chopsticks[i],0,1)==-1){13 perror("oops:em_init error!");14 exit(1);15 }16 }17if(sem_init(&sem_eaters,0,NUM-1)==-1){18 perror("oops:em_init error!");19 exit(1);20 }212223 }24252627//执⾏函数，每个线程相当于⼀个哲学家来进⾏28void * philosopher(void *ptid){29int pthread_id=*(int *)ptid%NUM;30 printf("%d philosopher is thinking...\n",(int)pthread_id);31 sem_wait(&sem_eaters);32//申请左筷⼦33 sem_wait(&sem_chopsticks[pthread_id]);34 printf("%d philosopher takes chopstick %d...\n",(int)pthread_id,(int)pthread_id);35//申请右筷⼦36 sem_wait(&sem_chopsticks[(pthread_id+1)%NUM]);37 printf("%d philosopher takes chopstick %d...\n",(int)pthread_id,((int)pthread_id+1)%NUM);38 printf("%d philosopher is eating, %d philosopher had already dined.\n",(int)pthread_id,eaters_num);39 sem_post(&sem_chopsticks[(pthread_id+1)%NUM]) ;40 sem_post(&sem_chopsticks[pthread_id]);41 sem_post(&sem_eaters);42 eaters_num++;//吃过⼀次的⼈加加43 printf("%d philosopher had dined, by now %d philosopher had already dined.\n",(int)pthread_id,eaters_num); 4445 }4647484950int main(int argc,char *argv[]){51int i,l,j,k;52//循环五个线程多少次53for(l=0;l<1;++l){54 printf("*******%d times try *******",l+1);55 pthread_t philosopher_threads[NUM];56 sem_signal_init();57//循环创建五个线程并执⾏58for(i=0;i<NUM;i++){5960 printf("%d times\n",i);61if(pthread_create(&philosopher_threads[i],NULL,philosopher,&ID[i])!=0){62 perror("oops:pthread_create error!");63 exit(1);6465 }666768 }6970//⽗线程等待⼦线程都结束才继续执⾏71for(j=0;j<NUM;j++){72 pthread_join(philosopher_threads[j],NULL);73 }74//结束销毁信号量75 sem_destroy(&sem_eaters);76for(k=0;k<NUM;++k){77 sem_destroy(&sem_chopsticks[k]);78 }79 eaters_num=0;80 sleep(2);818283 }84858687return0;88 }运⾏结果如下：1 philosopher is thinking...0 philosopher takes chopstick 0...3 times1 philosopher takes chopstick 1...2 philosopher is thinking...4 times1 philosopher takes chopstick 2...1 philosopher is eating, 0 philosopher had already dined.3 philosopher is thinking...4 philosopher is thinking...1 philosopher had dined, by now 1 philosopher had already dined.2 philosopher takes chopstick 2...0 philosopher takes chopstick 1...0 philosopher is eating, 1 philosopher had already dined.4 philosopher takes chopstick 4...3 philosopher takes chopstick 3...0 philosopher had dined, by now 2 philosopher had already dined.4 philosopher takes chopstick 0...4 philosopher is eating, 2 philosopher had already dined.4 philosopher had dined, by now 3 philosopher had already dined.3 philosopher takes chopstick 4...3 philosopher is eating, 3 philosopher had already dined.3 philosopher had dined, by now4 philosopher had already dined.2 philosopher takes chopstick 3...2 philosopher is eating, 4 philosopher had already dined.2 philosopher had dined, by now 5 philosopher had already dined.--------------------------------Process exited after 2.127 seconds with return value 0请按任意键继续. . .后续⽅案将继续更新请关注。

操作系统哲学家就餐问题课程设计c语言

1．设计题目与要求
1.1 设计题目描述：
用多线程同步方法解决哲学家就餐问题(Dining-Philosophers Problem)
1.2 要求：
1）为每个哲学家产生一个线程，设计正确的同步算法 2）每个哲学家取得一双筷子开始用餐后，即时显示“Dining…”和该哲学家的自定义标识符以及餐桌上所有几位哲学家标识符及其所坐的位置。 3）设定共有 5 个哲学家需用餐。每位用餐耗时 10 秒钟以上。 4）多个哲学家须共享操作函数代码。
针对每个哲学家通过共享操作函数代码分别建立5个线程以实现同步哲学家就餐而申请进入餐厅的哲学家进入room的等待队列根据fifo的原则总会进入到餐厅就餐因此不会出现饿死和死锁的现象针对5只筷子分别设置了5个互斥信号量以保证每只筷子每次只能被取得一次
武汉理工大学《操作系统》课程设计
题目 : 用多线程同步方法解决哲学家就餐问题 (Dining-Philosophers
2．设计说明书内容要求： Nhomakorabea1)设计题目与要求 2)总的设计思想及系统平台、语言、工具等。 3）数据结构与模块说明（功能与流程图） 4）给出用户名、源程序名、目标程序名和源程序及其运行结果。（要注明存储各个程序及其运行结果的 Linux 主机 IP 地址和目录。） 5）运行结果与运行情况（提示: (1)连续存储区可用数组实现。 (2)编译命令可用： cc (3)多线程编程方法参见附件。）
2.2 系统平台、语言及工具
（1）操作系统：Linux （2）程序设计语言：C 语言（3）工具：编辑工具 Vi、编译器 gcc
1
武汉理工大学《操作系统》课程设计
3．数据结构与模块说明
线程创建函数 pthread_create 声明如下： #include <pthread.h> int pthread_create (pthread_t *thread,pthread_attr_t *attr,Void* (*start_routine)(void *),void *arg);

操作系统实验报告哲学家就餐

操作系统实验报告哲学家就餐一、实验目的：通过模拟哲学家就餐问题，了解并掌握操作系统中的进程同步机制，以及解决进程间资源竞争所引发的死锁问题。

二、实验介绍：哲学家就餐问题是由荷兰计算机科学家伊克斯特拉(Dijkstra)于1965年首次提出的。

其问题描述如下：五位哲学家坐在一张圆桌子周围，每个哲学家面前有一碗饭和一根筷子。

哲学家的生活方式是交替地进行思考和进食。

当一个哲学家思考时，他不需要使用他的两个筷子；当一个哲学家想吃饭时，他需要同时获取他的左右两个筷子，并在获取到筷子后才能开始进食。

问题的关键是如何解决哲学家间的筷子竞争问题，以及避免死锁的发生。

三、实验设计：1.并发思路每个哲学家作为一个进程，在进行思考和进食这两个操作之前，需要获取他的两个筷子。

接下来考虑进程同步的两个关键点：-互斥：保证每个筷子同时只能被一个哲学家使用，避免资源竞争问题。

-死锁避免：通过限制只允许至多四位哲学家同时持有筷子，从而避免死锁发生。

2.进程同步机制- 互斥：使用Semaphore实现互斥，每个筷子都是一个Semaphore，初始值为1-死锁避免：引入一个全局计数器，记录当前持有筷子的哲学家数量，每次哲学家想要获取筷子时，先检查该计数器，仅当计数器小于4时才会获取筷子。

四、实验步骤：1.创建5个哲学家进程和5个筷子线程。

2.每个哲学家的线程循环执行思考和进食操作。

3.在进食之前，哲学家需要获取两个筷子，获取筷子的顺序按照哲学家编号进行，每个哲学家先获取自己的左边筷子，再获取自己的右边筷子。

4.进行进食操作后，哲学家释放两个筷子。

5.循环执行步骤3和步骤4，直到实验结束。

五、实验结果：通过观察实验结果，可以看到哲学家的思考和进食操作交替进行，并且避免了死锁的发生。

六、实验总结：通过本次实验，我了解了操作系统中的进程同步机制，并学会了如何解决资源竞争和死锁问题。

在本实验中，我使用了Semaphore和全局计数器实现了互斥和死锁避免，从而成功模拟了哲学家就餐问题。

哲学家就餐问题解决死锁的三种思路

哲学家就餐问题是计算机科学中一个经典的同步问题，它描述了五位哲学家围坐在圆桌前就餐，每位哲学家必须先拿起右边的餐具再拿起左边的餐具，但每次只能有一位哲学家拿起餐具就餐。

这个问题的关键在于如何避免死锁，即所有哲学家都拿起了右边的餐具，然后等待拿左边餐具的哲学家放下右边的餐具。

为了解决这个问题，计算机科学家提出了三种思路。

第一种思路是引入一个“服务生”，服务生负责给哲学家提供餐具，每次只允许一个哲学家向服务生请求餐具，这样就可以避免死锁。

然而，这种方法可能会引入新的竞争条件，服务生可能会成为新的瓶颈，从而降低系统的效率。

第二种思路是引入资源分级，为了避免死锁，可以给每个哲学家的餐具加上编号，要求哲学家先拿编号较小的餐具，再拿编号较大的餐具。

这样就可以避免死锁，但是可能会增加系统的复杂性，需要管理更多的资源状态。

第三种思路是破坏死锁的四个必要条件之一。

死锁发生的四个必要条件分别是互斥、请求并持有、不可剥夺和循环等待。

为了避免死锁，可以破坏其中一个或多个条件。

可以引入超时机制，当哲学家拿到一个餐具后，一定时间内没有获得另一个餐具，就放下手中的餐具，避免形成循环等待。

这种方法可以在不增加系统复杂性的情况下有效地解决死锁问题。

在我看来，这三种思路各有优缺点，要根据具体的场景和需求选择合适的方法。

不同的问题可能需要采用不同的思路来解决，需要权衡各种因素来做出最佳的决策。

哲学家就餐问题是一个充满哲学思考的经典问题，它不仅考察了计算机科学中的同步与互斥问题，更可以引发我们对于资源分配、竞争条件和系统设计的深入思考。

通过对哲学家就餐问题的深入理解，我们可以更加灵活地运用不同的思路解决实际中的问题，让我们的系统更加健壮和高效。

结语：通过对哲学家就餐问题的深入探讨，我们可以发现在计算机科学中，解决死锁问题有很多种思路，每种思路都有其独特的优缺点。

只有充分理解这些思路并根据具体情况做出权衡，才能更好地解决实际中遇到的死锁问题。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

相关系统调用
3、 exit (int status) 终止现运行进程，将status传递给父进程。
2020/5/5
#include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include <stdlib.h> main() { pid_t pc,pr; pc=fork(); if(pc<0) /* 如果出错 */
2020/5/5
semget
创建信号量集合过程的简单描述：一个新的信号量集合, 返回其semid; else if ((semflg&IPC_CREAT) && (!(semflg&IPC_EXCL)))
if (与key相关的信号量集合存在) 直接返回其semid; else在系统中创建一个新的信号量集合,返回其semid; else if ((semflg&IPC_CREAT) && (semflg&IPC_EXCL)) if (与key相关的信号量集合存在) 返回 -1; else在系统中创建一个新的信号量集合,返回其semid; else 不创建信号量，返回 -1.
2020/5/5
IPC通信机制简介
UNIX System V中提供了一系列新的进程通信机构，即IPC机构。其出现大大加强了UNIX的进程间通信功能。它包括三种：消息传送、信号量和共享存储器。
2020/5/5
IPC信号量机制中的有关系统调用
1、 #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h>
2020/5/5
相关系统调用
1、fork () 功能：创建子进程。入口参数：无。出口参数：正确时，对父进程返回值为子进程的pid (正整数)，对子进程返回0。错误时，返回值为 -1。
2020/5/5
fork ()
注意：在子进程刚被创建时，它和其父进程具有相同的共享正文段，而其他进程信息（数据段，栈等）则完全拷贝父进程而得到。
2020/5/5
semget
如何确定key：使用函数key_t ftok (char *path , char id)。
它返回由path和id所确定的IPC键值，当两者中任一不同时将返回不同的键值。若path提供的文件名不存在则返回 -1。
2020/5/5
#include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int main() {
printf("error ocurred!\n"); else if(pc==0){ /* 如果是子进程 */
printf("This is child process with pid of %d\n",getpid()); sleep(3); /* 睡眠10秒钟 */ } else{ /* 如果是父进程 */ pr=wait(NULL); /* 在这里等待 */ printf("I catched a child process with pid of %d\n"),pr); } exit(0); }
int semid, numsems=5; if((semid=semget(IPC_PRIVATE,numsems,IPC_CREAT|0660)) ==-1) {
return(-1); } return(semid); }
2020/5/5
IPC信号量机制中的有关系统调用
2、int semctl (int semid, int semnum, int cmd, union
2020/5/5
相关系统调用
2、当父进程通过fork创建了子进程之后, 父进程和子进程的执行顺序是无法控制的。如果想控制, 可以让父进程调用等待函数wait。 #include <sys/types.h> #include <sys/wait.h> pid_t wait(int *status); 函数返回: 若成功则为进程ID，若当前无子进程则返回 -1 。参数说明: status: 如果是不是空指针, 则子进程的返回状态保存在该 20指20/5针/5 指向的整型变量中; 如果是空指针, 则忽略返回状态.
ushort *array;
2020/5/5
struct seminfo *__buf;
semctl
④cmd：命令名。常用的有以下几个： • GETVAL：返回第semnum个信号量的值。 • SETVAL：设置第semnum个信号量的值，值放在arg.val • GETALL：读信号量集中所有信号量的值(放在arg.array) • SETALL：设置信号量集中所有信号量的值(放在arg.array) • IPC_RMID：删除由semid确定的信号量集合。
int semget (key_t key, int nsems, int semflg) 功能：创建一个信号量集合，分配相应数据结构并返回与之对应的信号量标识符，出错时返回 -1 。
2020/5/5
semget参数说明
① key：信号集的键 ② nsems：创建的信号量集合中包含的信号量个数 ③ semflg：信号存取权标志与建立标志。其中其低9
semun arg) 功能：按cmd指出的命令对和semid对应的信号量集进行控制，失败时返回 -1。参数说明：
①semid：合法信号量集合的标识。
②semnum：信号量集合中的所要控制的信号量编号(从0开始)。 ③arg：命令参数。union semun含有以下几个域：
int val;
struct semid_ds *buf;
位为表示信号的存取权限(拥有者，同一使用群及其它用户) ，这与文件系统的类似。建立标志则有两个，分别IPC_CREAT和IPC_EXCL
IPC_CREAT：若该信号不存在，semget将建立它。 IPC_EXCL：只有在信号集不存在的情况下，新的信号才会建立。否则 semget()将返回-1，并设置错误码。