本次实验比较简单，相较于前几届需要在linux0.11 底下实现信号量,这次只需要在linux下写个利用信号量解决生产者消费者问题已经很简单了.
实验要求：
在Ubuntu上编写应用程序“pc.c”，解决经典的生产者—消费者问题，完成下面的功能：
- 建立一个生产者进程，N个消费者进程（N>1）；
- 用文件建立一个共享缓冲区；
- 生产者进程依次向缓冲区写入整数0,1,2,...,M，M>=500；
- 消费者进程从缓冲区读数，每次读一个，并将读出的数字从缓冲区删除，然后将本进程ID和数字输出到标准输出；
缓冲区同时最多只能保存10个数。
要求用信号量来解决问题：
pc.c中将会用到sem_open()、sem_close()、sem_wait()和sem_post()等信号量相关的系统调用
要用到的函数说明：
int fseek(FILE *stream, long offset, int fromwhere);
函数设置文件指针stream的位置。
如果执行成功，stream将指向以fromwhere为基准，偏移offset（指针偏移量）个字节的位置，函数返回0。
如果执行失败(比如offset超过文件自身大小)，则不改变stream指向的位置，函数返回一个非0值。
size_t fread(void *buffer,size_t size,size_t count, FILE *stream );
buffer 是读取的数据存放的内存的指针
size 是每次读取的字节数
count 是读取次数
stream 是要读取的文件的指针
从一个文件流中读数据，最多读取count个元素，每个元素size字节，如果调用成功返回实际读取到的元素个数，如果不成功或读到文件末尾返回 0。
size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream);
（1）buffer：是一个指针，对fwrite来说，是要获取数据的地址；
（2）size：要写入内容的单字节数；
（3）count:要进行写入size字节的数据项的个数；
（4）stream:目标文件指针；
（5）返回实际写入的数据项个数count。
思路:建立文件缓冲区
0-9位存生产的数据,第10位存储当前读到的位置.
消费者读取的位置的时候要执行两次,一次读出当前所读位置,第二次根据此位置计算位偏移;
fseek( fp, 10*sizeof(int), SEEK_SET );
fread( &Outpos, sizeof(int), 1, fp);
fseek( fp, Outpos*sizeof(int), SEEK_SET );
fread( &costnum, sizeof(int), 1, fp);
下面是实验所需文件pc.c:
#define __LIBRARY__
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#define ALLNUM 550
#define CUSTOMERNUM 5
#define BUFFERSIZE 10
void Producters(pid_t pid,FILE *fp);
void Customer(pid_t pid,FILE *fp);
sem_t *empty,*full,*mutex;
FILE *fp=NULL;
int Inpos=0;
int Outpos=0;
int main()
{
int i,j,k;
pid_t producter;
pid_t customer;
empty=(sem_t *)sem_open("empty",O_CREAT,0064,10);
full=(sem_t *)sem_open("full",O_CREAT,0064,0);
mutex=(sem_t*)sem_open("mutex",O_CREAT,0064,1);
//开启三个信号量
fp=fopen("products.txt","wb+");
fseek(fp,10*sizeof(int),SEEK_SET);
fwrite(&Outpos,sizeof(int),1,fp);
fflush(fp);
producter=fork();
if(producter==0)
{
Producters(producter,fp);
}
for (i=0;i<CUSTOMERNUM;i++)
{
customer=fork();
if(customer==0)
{
Customer(customer,fp);
}
}
wait(NULL);
wait(NULL);
wait(NULL);
wait(NULL);
wait(NULL);
wait(NULL);
//开了6个进程
sem_unlink("empty");
sem_unlink("full");
sem_unlink("mutex");
fclose(fp);
return 0;
}
void Producters(pid_t pid,FILE *fp)
{
int i=0;
for (i=0;i<ALLNUM;i++)
{
sem_wait(empty);
sem_wait(mutex);
fseek( fp, Inpos * sizeof(int), SEEK_SET );
fwrite(&i,sizeof(int),1,fp);
fflush(fp);
Inpos=(Inpos +1) % BUFFERSIZE;
sem_post(mutex);
sem_post(full);
}
return;
}
void Customer(pid_t pid,FILE *fp)
{
int j,productid;
for (j=0;j<ALLNUM/CUSTOMERNUM;j++)
{
sem_wait(full);
sem_wait(mutex);
fflush(stdout);
fseek(fp,10*sizeof(int),SEEK_SET);
fread(&Outpos,sizeof(int),1,fp);
fseek(fp,Outpos*sizeof(int),SEEK_SET);
fread(&productid,sizeof(int),1,fp);
printf("%d: %d\n",getpid(),productid);
fflush(stdout);
Outpos=(Outpos+1)% BUFFERSIZE;
fseek(fp,10*sizeof(int),SEEK_SET);
fwrite(&Outpos,sizeof(int),1,fp);
fflush(fp);
sem_post(mutex);
sem_post(empty);
}
return;
}
报告:
（1）在pc.c中去掉所有与信号量有关的代码，再运行程序，执行效果有变化吗？为什么会这样？
执行结果Customer的消费数据没有按递增的顺序输出,而且且fread()函数将产生错误;
原因:
因为没有信号量P(S)控制，导致生产者可能在缓冲区满后继续生产，导致没有被消费的数据被覆盖，使得消费者消费的数据不是递增序列。
同时，没有信号量V(S)控制，导致消费者可能在读取所有数据后仍然继续读取，导致读取的数据无效。
没有mutex信号量控制导致出现多进程并发访问缓冲区，导致出现fread()错误。
（2）实验的设计者在第一次编写生产者——消费者程序的时候，是这么做的：
Producer()
{ P(Mutex); //互斥信号量
生产一个产品item;
P(Empty); //空闲缓存资源
将item放到空闲缓存中;
V(Full); //产品资源
V(Mutex);
}
Consumer()
{ P(Mutex);
P(Full);
从缓存区取出一个赋值给item;
V(Empty);
消费产品item;
V(Mutex);
}
这样可行吗？如果可行，那么它和标准解法在执行效果上会有什么不同？如果不可行，那么它有什么问题使它不可行？
这样做不可行，只有当缓冲区可写或者可读时，才能锁定该临界资源，否则容易出现缓冲区未锁定（mutex=1），consumer锁定该缓冲区，却发现empty=10，full=0，等待缓冲区有字符信号量，这样程序会进入死锁状态。
