生产者和消费者模型：

• 有若干个缓冲区，生产者不断向里填数据，消费者不断从中取数据
• 两者不冲突的前提：
  • 缓冲区有若干个，且是固定大小，生产者和消费者各有若干个
  • 生产者向缓冲区中填数据前需要判断缓冲区是否满，满了则等待，直到有空间
  • 消费者从缓冲区中取数据前需要判断缓冲区是否为空，空了则等待，直到缓冲区有数据
  • 在某一时刻，缓冲区中只允许有一个操作者进行读或者写操作

通过信号量，则可以将以上提出的不冲突的前提一一解决。当信号量的value值为0时，则对当前信号量进行p操作（-1）时当前进程会挂起，直到信号量的value值为1。

当前生产者消费者模型并不友好，即生产者和消费者都需要受灾人口缓冲区前等待，判断是否能够写入或者取出，极大得浪费了系统空间。后期的优化应该为，当生产者写满之后向消费者发送一个可以来取信息的信号之后就离开，去做自己的事情。而消费者取完之后发送一个信号告诉生产者取完了，可以继续写入，消费者即可回去做自己的事情。

后期的优化待了解了进程信号处理方式之后合入当前生产者消费者模型之中

编程实例

• 2个生产者每隔1秒向缓冲区中写入一次数据
• 3个消费者每3秒，3秒，5秒从缓冲区中读出数据
• 2个生产者分别对写信号量做P操作，对读信号量做V操作
• 3个消费者分别对写信号量做V操作，对读信号量做P操作
  
  

代码如下：

productor.c生产者

#include
#include 
#include 
#include 
#include #include 
#include 
#include 
#include //向获取到达共享内存的地址中写入值为data 的数据
//使用index表示当前数组下标同时表示当前缓冲区有多少个元素
//随着数据的不断写入，下标不断增加
void mem_write(int *addr, int data) { int index;index = addr[0];index ++;addr[index] = data;addr[0] = index;
}union semnum { int val;struct semid_ds *buf;unsigned short int *array;struct seminfo *__buf;
};
int sem_id;//初始化信号量的编号以及信号量的value值
void sem_init(int semid, int nsignum, int sem_value) { union semnum sem_union;sem_union.val = sem_value;if (semctl(semid,nsignum,SETVAL,sem_union) == -1) { printf("semctl failed
");_exit(-1);}
}//信号量-1操作，即编号为nsignum的信号量的value进行-1操作
void sem_p(int semid, int nsignum) { struct sembuf sops;sops.sem_num = nsignum;sops.sem_op = -1;sops.sem_flg = SEM_UNDO;if (semop(sem_id, &sops,1) == -1) { printf("semop P failed 
");_exit(-1);}}//信号量+1 操作，即编号为nsignum的信号量的value进行+1操作
void sem_v(int sem_id, int nsignum) { struct sembuf sops;sops.sem_num = nsignum;sops.sem_op = 1;sops.sem_flg = SEM_UNDO;if (semop(sem_id, &sops,1) == -1) { printf("semop V failed 
");_exit(-1);}
}//打印信号量，通过semctl获取信号量的数据结构，暂时没有用到
void sem_print(int sem_id, int nsignum) { int sem_value;sem_value = semctl(sem_id, nsignum, GETVAL);printf("sem[%d] = %d 
",nsignum, sem_value);
}int main() { //生成共享内存和信号量的keyint shm_id;key_t shm_key = ftok("./",111);key_t sem_key = ftok("./",112);//shmget获取共享内存的IPC标识，并进行内存的映射shmat得到共享内存的地址shm_id = shmget(shm_key, 1028, IPC_CREAT|0666);char *shm_addr = shmat(shm_id,NULL,0);//memset (shm_adr,0,sizeof(shm_addr));memset (shm_addr,0,128);//通过key生成信号量的IPC标识sem_id = semget(sem_key, 2,IPC_CREAT | 0666);if (sem_id == -1) { printf("semget failed
");_exit(-1);} else { sem_init(sem_id,0,0); //read sem//写信号量初始化为5，表示可以写5个缓冲区，即我们上图中描述的支持写入5个bufsem_init(sem_id,1,5); //write sem}int ret;if( (ret = fork()) == -1 ) { printf("fork failed
");_exit(-1);}//创建子进程，每隔一秒，写入数据else if (ret == 0) { int child_data = 1;while (1) { sleep(1);//写入之前将写信号量进行p操作（-1），表示写入一个缓冲区sem_p(sem_id,1);printf("child data  %d
",child_data);mem_write((int *)shm_addr,child_data);child_data += 2;//写之后将读信号量进行v操作（+1），表示支持读一个缓冲区sem_v(sem_id,0);}}//父进程每隔一秒写入数据else { int parent_data = 2;while(1) { sleep(1);sem_p(sem_id ,1);printf("parent_data %d
",parent_data);mem_write((int *)shm_addr, parent_data);parent_data = parent_data + 2;sem_v(sem_id,0);}}
}

consumer.c消费者

#include
#include 
#include 
#include 
#include #include 
#include 
#include 
#include //这里读时和mem_write相反，此时从共享内存中读出一个数据
//同时将index--；表示读出了一个数据，已经支持向内存写入
int mem_read(int *addr) { int index, data;index = addr[0];data = addr[index];index --;addr[0] = index;return data;
}union semnum { int val;struct semid_ds *buf;unsigned short int *array;struct seminfo *__buf;
};
int sem_id;void sem_init(int semid, int nsignum, int sem_value) { union semnum sem_union;sem_union.val = sem_value;if (semctl(semid,nsignum,SETVAL,sem_union) == -1) { printf("semctl failed
");_exit(-1);}
}void sem_p(int semid, int nsignum) { struct sembuf sops;sops.sem_num = nsignum;sops.sem_op = -1;sops.sem_flg = SEM_UNDO;if (semop(sem_id, &sops,1) == -1) { //printf("semop P failed 
");//_exit(-1);}}void sem_v(int sem_id, int nsignum) { struct sembuf sops;sops.sem_num = nsignum;sops.sem_op = 1;sops.sem_flg = SEM_UNDO;if (semop(sem_id, &sops,1) == -1) { //printf("semop v failed 
");// _exit(-1);}
}void sem_print(int sem_id, int nsignum) { int sem_value;sem_value = semctl(sem_id, nsignum, GETVAL);printf("sem[%d] = %d 
",nsignum, sem_value);
}int main() { //共享内存和信号量都支持key形式的对象生成int shm_id,sem_id;key_t shm_key = ftok("./",111);key_t sem_key = ftok("./",112);//获取共享内存的IPC标识，并进行内存的映射得到共享内存的地址shm_id = shmget(shm_key, 1028, IPC_CREAT|0666);char *shm_addr = shmat(shm_id,NULL,0);memset (shm_addr,0,128);//通过key生成信号量的IPC标识sem_id = semget(sem_key, 2,IPC_CREAT | 0666);if (sem_id == -1) { printf("semget failed
");_exit(-1);} else { sem_init(sem_id,0,0); //read semsem_init(sem_id,1,5); //write sem}//创建两个子进程读，每隔三秒读一个缓冲区//读之前将读信号量p（-1）操作，表示读一个信号量//读之后将写信号量v（+1）操作，表示支持写一个信号量for (int i = 0;i < 2; ++i) { int ret;if ((ret = fork()) == -1) { printf("fork failed
");_exit(-1);} else if (ret == 0) { while (1) { sleep(3);sem_p (sem_id, 0);printf("pid %d data :%d
",getpid(), mem_read((int *)shm_addr));sem_v (sem_id,1);}}}//父进程同样的方式也进行读while(1) { sleep(5);sem_p(sem_id , 0);printf("pid %d data :%d
",getpid(), mem_read((int *)shm_addr));sem_v(sem_id, 1);}return 0;
}

运行结果如下：

system V 信号量的通信特点

• 信号量是通过标识而不是常用的文件描述符来引用的
• 使用键而不是文件名来表示信号量
• 创建，初始化，操作信号量需要单独的系统调用，分别为semget,semctl,semop；关于system V 信号量的详细使用可以参考文章linux进程间通信：system V 信号量
• 信号量的操作同样会有阻塞现象。当信号量的value值为0时，则对当前信号量进行p操作（-1）时当前进程会挂起，直到信号量的value值为1。