进程间同步互斥经典问题(一)生产者-消费者问题
2018-02-28 16:54
531 查看
[align=left]http://blog.csdn.net/qq_24451605/article/details/49563045[/align]
制造商的工作是制造一段数据,放进缓存,如此重复。
消费者一次消费一段数据,从缓存中取出。
要保证不让制造商在缓存还是满的时候仍要向内写数据,不让消费者试图从空的缓存中取出数据。
要避免生产商和消费者同时睡觉,造成死锁
要避免多个消费者竞争同一段数据的情况
empty:用来表示空位的数量,初值为n(缓存区的规模)
full:用来表示剩余商品的数量,初值为0
mutex:用来表示互斥量,同一时间共享的内存只能由一个进程访问。
首先考虑生产商,在多个生产商和多个消费者同时运行的情况下:
1.检查共享内存是否满
如果满,说明无法急需生产,那么睡觉。
否则,p(empty),进程继续
2.每一个生产商在执行操作前申请互斥锁
如果被其他进程上锁,说明当前共享内存区域被其他进程使用,那么进入等待队列等待互斥锁被释放
否则,对互斥锁上锁,进程继续
3.生产一个新的商品放入空位,并且释放互斥锁,v(full)
然后考虑消费者,在多个消费者和多个生产商同时存在的情况下:
1.检查共享的内存中数据是否为空
如果空,说明无法消费,那么睡觉
否则,p(full),进程继续
2.在执行操作前申请互斥锁
如果被其他进程上锁,说明当前共享内存区域被其他进程使用,那么进入等待队列等待互斥锁被释放
否则,对互斥锁上锁,进程继续
3.消费一个商品,并且释放互斥锁,v(empty)
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: 生产商的进程代码
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: 消费者的进程代码
问题描述:
生产者-消费者问题,也叫做缓存绑定问题(bounded-buffer),是一个多进程同步问题。即有两个进程:制造少和消费者,共享一个固定大小的缓存制造商的工作是制造一段数据,放进缓存,如此重复。
消费者一次消费一段数据,从缓存中取出。
要保证不让制造商在缓存还是满的时候仍要向内写数据,不让消费者试图从空的缓存中取出数据。
问题分析:
要避免多个生产商竞争一个空位的情况。要避免生产商和消费者同时睡觉,造成死锁
要避免多个消费者竞争同一段数据的情况
基本思路:
首先我们需要定义三个信号量:empty:用来表示空位的数量,初值为n(缓存区的规模)
full:用来表示剩余商品的数量,初值为0
mutex:用来表示互斥量,同一时间共享的内存只能由一个进程访问。
首先考虑生产商,在多个生产商和多个消费者同时运行的情况下:
1.检查共享内存是否满
如果满,说明无法急需生产,那么睡觉。
否则,p(empty),进程继续
2.每一个生产商在执行操作前申请互斥锁
如果被其他进程上锁,说明当前共享内存区域被其他进程使用,那么进入等待队列等待互斥锁被释放
否则,对互斥锁上锁,进程继续
3.生产一个新的商品放入空位,并且释放互斥锁,v(full)
然后考虑消费者,在多个消费者和多个生产商同时存在的情况下:
1.检查共享的内存中数据是否为空
如果空,说明无法消费,那么睡觉
否则,p(full),进程继续
2.在执行操作前申请互斥锁
如果被其他进程上锁,说明当前共享内存区域被其他进程使用,那么进入等待队列等待互斥锁被释放
否则,对互斥锁上锁,进程继续
3.消费一个商品,并且释放互斥锁,v(empty)
注释完整的实现方案(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); }
相关文章推荐
- 进程同步互斥经典题之消费者与生产者问题
- 进程间同步互斥经典问题(一)生产者-消费者问题
- 操作系统经典同步互斥问题——生产者消费者问题
- 经典进程同步问题 生产者——消费者问题
- Linux下信号量实现进程同步、互斥(生产者消费者问题)
- 进程、线程知识点总结和同步(消费者生产者,读者写者三类问题)、互斥、异步、并发、并行、死锁、活锁的总结
- 经典生产者与消费者问题(线程的同步与互斥)
- 经典进程的同步问题-生产者与消费者
- 操作系统:经典进程同步问题(1)生产者-消费者问题
- 【操作系统总结】经典的进程同步问题-生产者消费者问题
- 经典进程同步问题-生产者与消费者
- 经典进程同步问题(一)——生产者、消费者问题
- 进程、线程知识点总结和同步(消费者生产者,读者写者三类问题)、互斥、异步、并发、并行、死锁、活锁的总结
- 用C#线程技术模拟“生产者-消费者”经典进程同步问题
- 操作系统学习笔记-信号量及PV操作与进程互斥和消费者生产者问题
- 进程同步---生产者与消费者问题以及进程同步机制--信号量及P、V操作
- python 生产者,消费者的同步互斥问题
- 进程同步---生产者与消费者问题以及进程同步机制--信号量及P、V操作
- 三个同步与互斥问题之生产者与消费者
- Linux下进程的同步互斥实例——生产者消费者