生产者消费者模型
生产者-消费者问题，也叫做缓存绑定问题(bounded-buffer),是一个多进程同步问题。
- 即有两个进程:制造少和消费者，共享一个固定大小的缓存
- 制造商的工作是制造一段数据，放进缓存，如此重复。
- 消费者一次消费一段数据，从缓存中取出。
- 要保证不让制造商在缓存还是满的时候仍要向内写数据，不让消费者试图从空的缓存中取出数据。
问题分析：
- 要避免多个生产商竞争一个空位的情况。
- 要避免生产商和消费者同时睡觉，造成死锁
- 要避免多个消费者竞争同一段数据的情况
基本思路：
- 首先我们需要定义三个信号量:
- empty:用来表示空位的数量，初值为n(缓存区的规模)
- full:用来表示剩余商品的数量，初值为0
- mutex:用来表示互斥量，同一时间共享的内存只能由一个进程访问。
- 首先考虑生产商，在多个生产商和多个消费者同时运行的情况下:
- 1.检查共享内存是否满
- 如果满，说明无法急需生产，那么睡觉。
- 否则，p(empty)，进程继续
- 2.每一个生产商在执行操作前申请互斥锁
- 如果被其他进程上锁，说明当前共享内存区域被其他进程使用，那么进入等待队列等待互斥锁被释放
- 否则，对互斥锁上锁，进程继续
- 3.生产一个新的商品放入空位，并且释放互斥锁，v(full)
- 1.检查共享内存是否满
- 然后考虑消费者，在多个消费者和多个生产商同时存在的情况下：
- 1.检查共享的内存中数据是否为空
- 如果空，说明无法消费，那么睡觉
- 否则，p(full)，进程继续
- 2.在执行操作前申请互斥锁
- 如果被其他进程上锁，说明当前共享内存区域被其他进程使用，那么进入等待队列等待互斥锁被释放
- 否则，对互斥锁上锁，进程继续
- 3.消费一个商品，并且释放互斥锁，v(empty)
- 1.检查共享的内存中数据是否为空
注释完整的实现方案(C语言)
- init.c : 对共享内存的数据进行初始化和清理工作
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/msg.h>
#include "ipc.h"
int main ( int argc , char * argv[] )
{
int i,producer_pid,consumer_pid,item,shmid;
semaphore mutex,empty,full;//定义互斥量mutex,定义信号量empty,full;
union semun sem_union;
void* shared_memory = (void*)0;
struct shared_use_st * shared_stuff;
/*
int semget ( key_t key , int num_sems , int sem_flags );
1.第一个参数key是一个用来允许不相关的进程访问相同信号量的整数值，
所有的信号量信号量是为不同的程序提供一个key来简介访问的,
对于每一个信号量系统生成一个信号量标识符。符号量键值只可以由semget
获得，所有其他的信号量函数所用的信号量标识符都是由semget所返回的。
2.num_sems参数是所需要的信号量数目，这个值通常是1
3.sem_flags参数是一个标记集合
IPC_CREAT与IPC_EXCL的组合来保证我们可以的到一个新的唯一的信号量
如果得不到会报错
4.返回值如果是一个整数，这是用于其他信号量函数的标识符，
如果失败，则会返回-1
*/
if ( ( mutex = semget ( (key_t) KEY_MUTEX , 1 , 0666|IPC_CREAT)) == -1 )
{
fprintf ( stderr , "Failed to create semaphore!");
exit(EXIT_FAILURE);
}
if (( empty = semget( (key_t) KEY_EMPTY , 1 , 0666|IPC_CREAT)) == -1 )
{
fprintf ( stderr , "Failed to create semaphore!");
exit(EXIT_FAILURE);
}
if (( full = semget((key_t) KEY_FULL , 1 , 0666|IPC_CREAT)) == -1 )
{
fprintf ( stderr , "Failed to create semaphore!");
exit(EXIT_FAILURE);
}
if ((shmid = shmget ((key_t)KEY_SHM,sizeof (struct shared_use_st),0666|IPC_CREAT))==-1)
{
fprintf ( stderr , "Failerd to create shared memory!");
exit(EXIT_FAILURE);
}
sem_union.val = 1;
if ( semctl(mutex,0,SETVAL,sem_union) == -1 )
{
fprintf ( stderr , "Failed to set semaphore!");
exit(EXIT_FAILURE);
}
sem_union.val = 0;
if ( semctl(full,0,SETVAL,sem_union) == -1 )
{
fprintf ( stderr , "Failed to set semaphore!");
exit(EXIT_FAILURE);
}
sem_union.val = BUFFER_SIZE;
if ( semctl(empty, 0 , SETVAL , sem_union) == -1 )
{
fprintf ( stderr , "Failed to set semaphore!");
exit(EXIT_FAILURE);
}
/*
void* shmat ( int shmid , const void* shmaddr , int shmflg )
链接共享内存标识符为shmid的共享内存，链接成功后把共享内存区对象
映射到调用进程的地址空间,随后可像本地空间一样访问。
shmid 共享内存标识符
shmaddr 指定共享内存出现在进程内存地址的什么位置，直接指定为NULL让内核自己决定
一个合适的地址位置.
SHM_RDONLY 为只读模式，其他为读写模式
*/
if (( shared_memory = shmat( shmid ,(void*)0 , 0)) == (void*)-1 )
{
fprintf ( stderr , "shmat failed\n");
exit(EXIT_FAILURE);
}
shared_stuff = ( struct shared_use_st * ) shared_memory;
for ( i = 0; i < BUFFER_SIZE ; i ++ )
{
shared_stuff->buffer[i] = 0;
}
shared_stuff->low = 0;
shared_stuff->high = 0;
shared_stuff->cur = 0;
exit(EXIT_SUCCESS);
}
/*
int shmdt ( const void* shmaddr )
与shmat相反，是用来断开与共享内存附加点的地址，进制本进程访问瓷片共享内存
shmaddr:链接共享内存的起始地址
成功返回0,除错返回-1
*/
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- producer.c： 生产商的进程代码
#include "ipc.h"
int main ( int argc , char * argv[] )
{
int i,item,shmid;
semaphore mutex,empty,full;
union semun sem_union;
void* shared_memory = (void*)0;
struct shared_use_st *shared_stuff;
if ((mutex = semget((key_t)KEY_MUTEX,1,0666|IPC_CREAT)) == -1 )
{
fprintf ( stderr , "Failed to create semaphore!");
exit(EXIT_FAILURE);
}
if ((empty = semget((key_t)KEY_EMPTY,1,0666|IPC_CREAT)) == -1 )
{
fprintf ( stderr , "Failed to create semaphore!");
exit(EXIT_FAILURE);
}
if ((full = semget((key_t)KEY_FULL,1,0666|IPC_CREAT)) == -1 )
{
fprintf ( stderr , "Failed to create semaphore!");
exit(EXIT_FAILURE);
}
if ((shmid=shmget((key_t)KEY_SHM,sizeof(struct shared_use_st),0666|IPC_CREAT)) == -1 )
{
fprintf ( stderr , "Failed to create semaphore!");
exit(EXIT_FAILURE);
}
if ((shared_memory = shmat(shmid,(void*)0,0)) == (void*)-1)
{
fprintf ( stderr , "shmat failed\n");
exit(EXIT_FAILURE);
}
shared_stuff = ( struct shared_use_st * ) shared_memory;
for ( i = 0 ; i < 30 ; i++ )
{
item = ++(shared_stuff->cur);
sleep(1);
printf ( "Producing item %d\n" , item );
sem_p ( empty );//减少一个空位
sem_p ( mutex );//锁上互斥锁
(shared_stuff->buffer)[(shared_stuff->high)] = item;
(shared_stuff->high) = ((shared_stuff->high)+1) % BUFFER_SIZE;
printf ( "Inserting item %d\n" , item );
sem_v ( mutex );
sem_v ( full );
}
if ( shmdt(shared_memory) == -1 )
{
fprintf ( stderr , "shmat failed\n");
exit(EXIT_FAILURE);
}
printf ( "Finish!\n" );
getchar();
exit(EXIT_SUCCESS);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- consumer.c: 消费者的进程代码
#include "ipc.h"
int main ( int argc , char* argv[] )
{
int i,item,shmid;
semaphore mutex,empty,full;
void* shared_memory = ( void* ) 0;
struct shared_use_st* shared_stuff;
if ((mutex=semget((key_t)KEY_MUTEX,1,0666|IPC_CREAT)) == -1 )
{
fprintf (stderr , "Failed to create semaphore!");
exit(EXIT_FAILURE);
}
if ((empty=semget((key_t)KEY_EMPTY,1,0666|IPC_CREAT)) == -1 )
{
fprintf (stderr , "Failed to create semaphore!");
exit(EXIT_FAILURE);
}
if ((full=semget((key_t)KEY_FULL,1,0666|IPC_CREAT)) == -1 )
{
fprintf (stderr , "Failed to create semaphore!");
exit(EXIT_FAILURE);
}
if ((shared_memory = shmat(shmid,(void*)0,0) ) ==(void*)-1 )
{
fprintf ( stderr , "shmat failed\n");
exit(EXIT_FAILURE);
}
shared_stuff = (struct shared_use_st*)shared_memory;
for(i=0;i<30;i++)
{
sem_p(full);
sem_p(mutex);
item = shared_stuff->buffer[shared_stuff->low];
(shared_stuff->buffer)[(shared_stuff->low)]=0;
shared_stuff->low = ((shared_stuff->low)+1)%BUFFER_SIZE;
printf ( "Removing item %d\n" , item );
sem_v(mutex);
sem_v(empty);
printf ( "Consuming item %d\n" ,item );
sleep(2);
}
if ( shmdt(shared_memory) == -1 )
{
fprintf ( stderr , "shmat failed\n" );
exit ( EXIT_FAILURE);
}
printf ( "Finish!\n" );
getchar();
exit(EXIT_SUCCESS);
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
