h>//time。
h是C标准库头文件，主要是一些和时间相关的函数
#include〈sys/types。
h>//基本系统数据类型
#include//declarationsforwaiting
#include//Semaphoreoperationflags
＃defineNUM_PROCS5//5个子进程
＃defineSEM_ID250//信号量
#defineFILE_NAME”/tmp/sem_aaa"
#defineDELAY4000000
voidupdate_file（intsem_set_id,char*file_path，intnumber）｛
structsembufsem_op;
FILE*file;//建立一个文件指针
//等待信号量的数值变为非负数，此处设为负值,相当于对信号量进行P操作
sem_op.sem_num=0；
sem_op。
sem_op=—1；
sem_op.sem_flg=0；
semop（sem_set_id,＆sem_op,1）；
/＊操作一组信号,进程的标识符号为sem_set_id，sem_op是结构指针。
sem_op：
如果其值为正数，该值会加到现有的信号内含值中，通常用于释放所控资源的使用权；如果sem_op的值为负数,而其绝对值又大于信号的现值，操作将会阻塞，直到信号值大于或等于sem_op的绝对值,通常用于获取资源的使用权；如果sem_op的值为0，则操作将暂时阻塞，直到信号的值变为0。
*/
//写文件，写入的数值是当前进程的进程号
file=fopen（file_path,"w”）;
//写文件,若成功则返回文件起始地址；否则置0
if（file）{//临界区
fprintf（file,”%d\n",number）;//将进程号写入＊file处
printf（”％d\n",number）；将当前的进程号输到标准输出里。
fclose（file）；//关闭文件
}
//发送信号，把信号量的数值加1，此处相当于对信号量进行V操作
sem_op.sem_num=0；
sem_op。
sem_op=1；
sem_op.sem_flg=0；
semop（sem_set_id，＆sem_op,1）;
}
//子进程写文件
voiddo_child_loop（intsem_set_id,char*file_name）｛
pid_tpid=getpid（）；
inti，j;//取得目前进程的识别码，返回当前的进程的标识符
for（i=0;i〈3;i++）｛
update_file（sem_set_id，file_name，pid）;
for（j=0；j<4000000；j++）；
｝
}
intmain（intargc,char*＊argv）
{
intsem_set_id;//信号量集的ID
unionsemunsem_val;//信号量的数值，用于semctl（）
intchild_pid；
inti;
intrc;
//建立信号量集，ID是250,其中只有一个信号量
sem_set_id=semget（SEM_ID，1，IPC_CREAT|0600）；
if（sem_set_id==—1）｛//若调用失败，输出错误类型,强制退出程序
perror（”main:
semget"）;
exit
（1）；
}
//把第一个信号量的数值设置为1
sem_val。
val=1;
rc=semctl（sem_set_id，0，SETVAL,sem_val）；
if（rc==-1）
{//测试是否成功调用semclt（）函数
perror（”main:
semctl"）;
exit
（1）;
｝
//建立一些子进程，使它们可以同时以竞争的方式访问信号量
for（i=0;i〈NUM_PROCS;i++）{
//通过fork（）函数创建子进程
child_pid=fork（）；
switch（child_pid）{
case—1:
perror（"fork"）;
case0：
//子进程写文件
do_child_loop（sem_set_id,FILE_NAME）;
exit（0）;
default：
//父进程接着运行
break；
}
｝
//等待子进程结束
for（i=0；i〈NUM_PROCS；i++）｛
intchild_status;
wait（&child_status）;
}
printf（”main：
we’redone\n"）；
fflush（stdout）；
return0；
｝
（二）生产者消费者问题
生产者消费者问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者"和“消费者”——在实际运行时会发生的问题。
生产者的主要作用是生成一定量的数据放到缓冲区中,然后重复此过程。
与此同时,消费者也在缓冲区消耗这些数据。
该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。
＃include#include〈sys/types。
h>
＃include〈linux/sem。
h〉
//系统读写安全相关函数
＃include〈fcntl。
h〉
＃include〈unistd。
h〉
#include〈stdio.h>
//该头文件内包含了通过错误码来回报错误资讯的宏
＃include#include〈time.h〉
#defineMAXSEM5
//声明三个信号灯ID
intfullid;
intemptyid;
intmutxid；
intmain（）
｛
/＊在sembuf结构中，sem_num是相对应的信号量集中的某一个资源，所以其值是一个从0到相应的信号量集的资源总数（ipc_perm.sem_nsems）之间的整数。
sem_op指明所要执行的操作，sem_flg说明函数semop的行为。
sem_op的值是一个整数。
释放相应的资源数，将sem_op的值加到信号量的值上.
＊/
structsembufP，V;
unionsemunarg；
//声明共享主存
int＊array;
int＊sum；
int＊set;
int*get;
//映射共享主存
/*mmap是一种内存映射文件的方法,即将一个文件或者其它对象映射到进程的地址空间
实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。
实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存
而系统会自动回写脏页面到对应的文件磁盘上
即完成了对文件的操作而不必再调用read，write等系统调用函数。
相反，内核空间对这段区域的修改也直接反映用户空间
从而可以实现不同进程间的文件共享.
*/
array=（int＊）mmap（NULL,sizeof（int）*MAXSEM,PROT_READ｜PROT_WRITE,MAP_SHARED｜MAP_ANONYMOUS，—1,0）；
sum=（int＊）mmap（NULL，sizeof（int）,PROT_READ｜PROT_WRITE，MAP_SHARED|MAP_ANONYMOUS，—1,0）；
get=（int＊）mmap（NULL，sizeof（int）,PROT_READ｜PROT_WRITE，MAP_SHARED｜MAP_ANONYMOUS，—1，0）;
set=（int＊）mmap（NULL，sizeof（int），PROT_READ｜PROT_WRITE，MAP_SHARED｜MAP_ANONYMOUS,—1，0）;＊sum=0;
＊get=0;
＊set=0；
//创建信号量、生成信号灯
fullid=semget（IPC_PRIVATE，1,IPC_CREAT｜00666）；
emptyid=semget（IPC_PRIVATE，1，IPC_CREAT｜00666）；
mutxid=semget（IPC_PRIVATE，1,IPC_CREAT|00666）;
//为信号灯赋值
arg。
val=0；
if（semctl（fullid，0,SETVAL，arg）==—1）perror（"semctlsetvalerror”）;
arg.val=MAXSEM；
if（semctl（emptyid,0,SETVAL，arg）==-1）perror（"semctlsetvalerror”）；
arg。
val=1;
if（semctl（mutxid,0,SETVAL，arg）==—1）perror（”setctlsetvalerror”）;
//初始化P,V操作
V.sem_num=0；
V.sem_op=1;
V.sem_flg=SEM_UNDO；
P.sem_num=0;
P。
sem_op=-1；
P.sem_flg=SEM_UNDO；
//生产者进程
if（fork（）==0）｛
inti=0；
while（i<100）
{
//semop（信号量，资源，数目）
semop（emptyid，＆P，1）;
//mutex实现临界资源的互斥使用
semop（mutxid，＆P，1）；
array［*（set）％MAXSEM］=i+1；
printf（"Producer％d\n"，array［（*set）%MAXSEM］）;
//生产产品的标号+1
（＊set）++;
semop（mutxid，＆V，1）；
semop（fullid,&V,1）;
i++；
}
sleep（10）；
printf（"Producerisover"）；
exit（0）；
｝else｛
//ConsumerA进程
if（fork（）==0）｛
while
（1）{
semop（fullid,＆P,1）；
semop（mutxid,＆P,1）;
//判断是否所有产品都被消费了
if（＊get==100）
break；
＊sum+=array［（＊get）%MAXSEM]；
printf（”TheComsumerAGetNumber％d\n",array[（＊get）%MAXSEM]）；
（＊get）++；
//判断这次消费是否为最后一次消费
if（＊get==100）
printf（"Thesumis％d\n"，*sum）;
semop（mutxid,＆V，1）;
semop（emptyid,&V,1）;
sleep
（1）;
｝
printf（”ConsumerAisover"）；
exit（0）；
}else{
//ConsumerB进程
if（fork（）==0）{
while
（1）{
semop（fullid，＆P,1）；
semop（mutxid,＆P,1）；
if（*get==100）
break;
＊sum+=array［（＊get）％MAXSEM］；
printf（”TheComsumerBGetNumber％d\n”，array[（＊get）％MAXSEM］）;
（＊get）++;
if（*get==100）
printf（"Thesumis％d\n”，＊sum）；
semop（mutxid,&V，1）；
semop（emptyid，&V，1）；
sleep
（1）;
}
printf（"ConsumerBisover"）；
exit（0）；
｝
}
}
//sleep（20）；
return0;
}
要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据.同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。
通常采用进程间通信的方法解决该问题，常用的方法有信号灯法等。
如果解决方法不够完善，则容易出现死锁的情况。
出现死锁时,两个线程都会陷入休眠，等待对方唤醒自己。
该问题也能被推广到多个生产者和消费者的情形。
思考:
1、关于sleep（）
Sleep函数对于指定的时间间隔挂起当前的执行线程。
格式:
VOIDSleep（DWORDdwMilliseconds）；dwMilliseconds：
定义挂起执行线程的时间,以毫秒（ms）为单位.取值为0时,该线程将余下的时间片交给处于就绪状态的同一优先级的其他线程。
若没有处于就绪状态的同一优先级的其他线程,则函数立即返回，该线程继续执行。
若取值为INFINITE则造成无限延迟。
2.关于semop
在Linux下，PV操作通过调用semop函数来实现。
该函数定义在头文件sys/sem。
h中，原型如下:
intsemop（intsemid,structsembuf*sops，size_tnsops）；
流程图:
（三）第三个程序没有调试好
（四）心得体会
程序的总体思路经过仔细分析还是比较清晰的.比如生产者消费者问题最主要的就是要实现两个条件判断，即缓冲区满的时候不允许生产者进行生产,若缓冲区空的话，则不进行消费者进行消费；在生产操作和消费操作之间进行相应的判断，正好符合PV信号量，先做P操作，若满足，则执行此进程,若不满足，则阻塞此进程，并做相应的V操作，即唤醒其对应的进程,从而很好的解决了生产者-—消费者问题。
纸上得来终觉浅，绝知此事要躬行。
升级会员 