操作系统实验二：进程同步程序设计

一、实验目的

1、 加深对进程概念的理解，明确进程和程序的区别。
2、 认识进程并发执行的实质
3、 掌握信号通信机制，实现进程之间通过信号实现互斥与同步的方法。

二、实验内容

桌子上有一只盘子，最多可容纳两个水果，每次只能放入或者取出一个水果。爸爸专门向盘子中放苹果，妈妈专门向盘子中放橘子，儿子专门等待吃盘子中的橘子，女儿专门等吃盘子中的苹果。试编程实现爸爸、妈妈、儿子、女儿四个人之间的同步。
（1）水果、盘子均通过导入图片来实现可视化；
（2）放水果、拿水果均有动画显示，包括把水果拿到手上去放、放完空手回来等均通过的动画予以展示；
（3）执行顺序由并发控制机制决定，而非通过延时实现；
（4）要求界面美观、动作流畅。

三、实验要求

1、 写出程序，并调试程序，要给出测试数据和实验结果。
2、 整理上机步骤，总结经验和体会。
3、 完成实验报告和上交程序。

四、实验代码

2.1.py 进程控制吃水果

import time
import random
from multiprocessing import Process, JoinableQueue
import multiprocessing as mp


"""
Process常用属性与方法：
    name:进程名
    pid：进程id
    run()，自定义子类时覆写
    start()，开启进程
    join(timeout=None)，阻塞进程
    terminate(),终止进程
    is_alive()，判断进程是否存活
    task_done()方法
JoinableQueuea:
    参考：https://blog.csdn.net/qq_36811322/article/details/88295637
    比原先队列多了一个方法task_done():当队列中的数据处理完会反馈给队列！
    join()方法：阻塞方法，当队列中的数据都task_done()完成后，join()就结束了
"""


def producer(q,name: str, food: str,l,g_num,g_apple,g_orange):
    l.acquire()  # 锁住
    time.sleep(random.uniform(0.1, 0.8))
    if food == '苹果':
        if g_num.value < 2 and g_apple.value < 1:
            g_apple.value = g_apple.value+1 # 设置为全局变量，使用方法对外部产生影响
            g_num.value = g_num.value+1
            q.put((1, food))
            print(f'{name}把{food}放到盘子里')
            print(f'现在桌子上有{g_apple.value}份苹果，{g_orange.value}份橘子!')
    elif food == '橘子':
        if g_num.value < 2 and g_orange.value < 1:
            g_orange.value = g_orange.value+1
            g_num.value = g_num.value+1
            q.put((1, food))
            print(f'{name}把{food}放到盘子里')
            print(f'现在桌子上有{g_apple.value}份苹果，{g_orange.value}份橘子!')
    # else:
    #     q.join()
    # q.task_done()
    l.release()  # 释放


def consumer(q1,q, name: str,food:str,l,g_capacity,g_num,g_apple,g_orange):
    res = q1.get()
    print(res) #(1, '苹果')
    time.sleep(random.uniform(0.1, 0.5))
    l.acquire()  # 锁住
    if (food=='橘子'or food=='苹果') and (res[1]=='橘子' or res[1]=='苹果'):
        g_num.value = g_num.value - 1
        if food == '橘子':
            g_orange.value = g_orange.value-1
        else:
            g_apple.value = g_apple.value - 1
        print(f'{name}从桌上拿走了{food}')
        print(f'现在桌子上有{g_apple.value}份苹果，{g_orange.value}份橘子!')
        # q.task_done()
    # else:
    #     q.join()
    l.release()  # 释放


if __name__ == '__main__':
    l = mp.Lock()  # 定义一个进程锁
    g_capacity = mp.Value('i', 2) # 最大容量
    g_num = mp.Value('i', 0) # 当前个数
    g_apple = mp.Value('i', 0) # 苹果个数
    g_orange = mp.Value('i', 0) # 橘子个数
    while True:
        q1 = JoinableQueue()
        p1 = Process(target=producer, args=(q1, '爸爸', '苹果',l,g_num,g_apple,g_orange))
        # print(p1)
        p1.start()
        # print(g_apple.value)
        q2 = JoinableQueue()
        p2 = Process(target=producer, args=(q2, '妈妈', '橘子',l,g_num,g_apple,g_orange))
        p2.start()
        q3 = JoinableQueue()
        c1 = Process(target=consumer, args=(q1,q3, '儿子','橘子',l,g_capacity,g_num,g_apple,g_orange))
        c1.daemon = True
        c1.start()
        q4 = JoinableQueue()
        c2 = Process(target=consumer, args=(q2,q4, '女儿','苹果',l,g_capacity,g_num,g_apple,g_orange))
        c2.daemon = True
        c2.start()

    # p1.join() # p1和p2的阻塞是为了让数据都生产结束，这样队列才能反馈处理结果
    # p2.join()
    # q.join() # 当队列数据反馈都数据结束后，阻塞才会结束


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

Test2.py 进程控制吃水果&可视化界面

import threading,time,pygame,sys

# 传入文件的 URL 注意此处的 URL 必须为绝对路径，否则会报错
background_image_filename = 'backgrand.jpg'
apple_image_filename = 'apple.png'
orange_image_filename = 'orange.png'
mom_image_filename = 'mom.png'
father_image_filename = 'dad.png'
son_image_filename = 'boy.png'
daughter_image_filename = 'girl.png'
dad_hand_image_filename = 'hand.png'
mom_hand_image_filename = 'hand.png'
son_hand_image_filename = 'hand.png'
daughter_hand_image_filename = 'hand.png'

# 初始化pygame，为使用硬件做准备
pygame.init()

# 放橘子和苹果时的 位置
one_size = (600, 400) # 列 宽
two_size = (900, 500)
dad_size = (100, 100)
mom_size = (100, 1300)
son_size = (700, 100)
daughter_size = (1300, 700)
dad_hand_size = (400, 200)
mom_hand_size = (1100,200)

screenSize = (1100,1700)

# 创建一个窗口
screen = pygame.display.set_mode(screenSize, 0, 32)

# 设置窗口标题
pygame.display.set_caption('吃水果进程')

# 加载图片并转换
# pygame.transform.scale(Surface, (width, height), DestSurface = None)(缩放)
background = pygame.image.load(background_image_filename)
background = pygame.transform.scale(background,(1100,1700))
appleim = pygame.image.load(apple_image_filename)
appleim = pygame.transform.scale(appleim,(200,200))
orangeim = pygame.image.load(orange_image_filename)
orangeim = pygame.transform.scale(orangeim,(200,200))
mom = pygame.image.load(mom_image_filename)
mom = pygame.transform.scale(mom,(300,300))
father = pygame.image.load(father_image_filename)
father = pygame.transform.scale(father,(300,300))
son = pygame.image.load(son_image_filename)
son = pygame.transform.scale(son,(300,300))
daughter = pygame.image.load(daughter_image_filename)
daughter = pygame.transform.scale(daughter,(300,300))
dad_hand = pygame.image.load(dad_hand_image_filename)
dad_hand = pygame.transform.scale(dad_hand,(200,200))
mom_hand = pygame.image.load(mom_hand_image_filename)
mom_hand = pygame.transform.scale(mom_hand,(200,200))
son_hand = pygame.image.load(son_hand_image_filename)
son_hand = pygame.transform.scale(son_hand,(200,200))
daughter_hand = pygame.image.load(daughter_hand_image_filename)
daughter_hand = pygame.transform.scale(daughter_hand,(200,200))

# 是否全屏
fullscreen = False

mutex = threading.Lock()
# 最大容量
capacity = 2
# 当前个数
num = 0
# 苹果个数
apple = 0
# 橘子个数
orange = 0

apple_lock = threading.Semaphore(0)
orange_lock = threading.Semaphore(0)
num_lock = threading.Semaphore(2)


def daughter_eat(name):
    global num, capacity ,apple ,orange

    while True:
        apple_lock.acquire()
        num_lock.release()
        mutex.acquire()
        for i in range(5):
            screen.blit(background, (0, 0))
            if num == 2:
                if orange == 2:
                    blitOne(appleim)
                elif orange == 1:
                    blitOne(orangeim)
            elif num == 1:
                pass
            blitPerson()
            screen.blit(daughter_hand, (1400 - i, 800 - i)) # 绘制的位置
            pygame.display.update()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    sys.exit()
        apple -= 1
        num -= 1
        print(name, "从桌子上拿走一个苹果")
        print("现在桌子上还有" + str(apple) + "苹果" + str(orange) + "橘子")
        mutex.release()
        time.sleep(3)


def son_eat(name):
    global num, capacity, apple, orange

    while True:
        orange_lock.acquire()
        num_lock.release()
        mutex.acquire()
        for i in range(5):
            screen.blit(background, (0, 0))
            if num == 2:
                if apple == 2:
                    blitOne(orangeim)
                elif apple == 1:
                    blitOne(appleim)
            elif num == 1:
                pass
            blitPerson()
            screen.blit(son_hand, (800 - i, 200 + i))
            pygame.display.update()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    sys.exit()
        orange -= 1
        num -= 1
        print(name, "从桌子上拿走一个橘子")
        print("现在桌子上还有" + str(apple) + "苹果" + str(orange) + "橘子")
        mutex.release()
        time.sleep(3)


# 爸爸放苹果
def father_put(name, fruit):
    global num, capacity, apple, orange
    while True:
        num_lock.acquire()
        apple_lock.release()
        mutex.acquire()
        print(name, "把", fruit, "放在盘子里面")
        for i in range(5):
            screen.blit(background, (0, 0))
            if i >= 4:
                if num == 0:
                    blitOne(appleim)
                elif num == 1:
                    if apple == 1:
                        blitOne(appleim)
                        blitTwo(appleim)
                    else:
                        blitOne(orangeim)
                        blitTwo(appleim)
            blitPerson()
            screen.blit(dad_hand, (200 + i, 200 + i))
            pygame.display.update()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    sys.exit()
        apple += 1
        num += 1
        print("在爸爸放苹果之后,桌子上苹果的数量: " + str(apple) + " 桌子上橘子的数量: " + str(orange))
        mutex.release()
        time.sleep(2)

# 妈妈放的是橘子
def mother_put(name, fruit):
    global num, capacity, apple, orange

    while True:
        # 获取锁，用于线程同步
        num_lock.acquire()
        # 释放锁
        orange_lock.release()
        # 获取互斥变量的锁
        mutex.acquire()
        print(name, "把", fruit, "放在盘子里面")
        for i in range(500):
            screen.blit(background, (0, 0))
            if i >= 49:
                if num == 0:
                    blitOne(orangeim)
                elif num == 1:
                    if orange == 1:
                        blitOne(orangeim)
                        blitTwo(orangeim)
                    else:
                        blitOne(appleim)
                        blitTwo(orangeim)
            blitPerson()
            screen.blit(mom_hand, (200 + i, 1100 - i))
            pygame.display.update()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    sys.exit()
        orange += 1
        num += 1
        print("在妈妈放橘子之后,桌子上苹果的数量: " + str(apple) + " 桌子上橘子的数量: " + str(orange))
        mutex.release()
        time.sleep(2)


def blitOne(fruit):
    screen.blit(fruit, one_size)
    blitPerson()


def blitTwo(fruit):
    screen.blit(fruit, two_size)
    blitPerson()


def blitPerson():
    screen.blit(father, dad_size)
    screen.blit(mom, mom_size)
    screen.blit(son, son_size)
    screen.blit(daughter, daughter_size)


if __name__ == "__main__":
    mother_thread = threading.Thread(target=mother_put, args=("妈妈", "橘子",))
    father_thread = threading.Thread(target=father_put, args=("爸爸", "苹果",))
    son_thread = threading.Thread(target=son_eat, args=("儿子",))
    daughter_thread = threading.Thread(target=daughter_eat, args=("女儿",))
    mother_thread.start()
    father_thread.start()
    son_thread.start()
    daughter_thread.start()
    time.sleep(10)


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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237

结果展示

问题及解决

1、 可视化页面设计之前，可以先绘制一个草图，并记录页面各点坐标。不要用PPT，不方便知道点之间的关系，可以用excel。


2、 Pygame可以加载图片pygame.image.load(image_filename)并调整大小pygame.transform.scale(background,(1100,1700))。
3、 设置线程变量锁apple_lock = threading.Semaphore(0)，线程中如果需要使用变量，那么线程开始时上锁apple_lock.acquire()，线程结束时解锁mutex.release()。
4、 由于pygame会读取所有可视化页面上的操作，因此点击页面会卡死。可以加上一行关于事件点击的代码，解决这个问题

for event in pygame.event.get():
    if event.type == pygame.QUIT:
        sys.exit()
1
2
3

5、 进程模块中，进程中不能改变gobal全局变量，可以用multiprocessing中的mp.value共享内存改变变量值。
6、 注意，定义一个共享内存l = mp.Lock()。共享内存操作前需要l.acquire() # 锁住，操作完成后需要l.release() # 释放。若进程作为def函数，那么共享内存锁需要作为参数一起被传过去。
7、 Multiprocessing模块中的 JoinableQueuea:
参考：https://blog.csdn.net/qq_36811322/article/details/88295637
其中，.get函数读取的是.put函数最后放到队列的那一个#(1, ‘苹果’)

实验心得

这个题是消费者—生产者问题的变形，需要先理清楚几点：
1、哪些操作是互斥的：对于盘子的访问要互斥的进行。且父母放与儿女拿需要两个不同的互斥量来实现，即m和n。
2、哪些操作是要同步进行的：父亲将苹果放入盘子后，女儿才能取苹果。母亲将橘子放入盘子后，儿子才能取橘子。只有盘子为空时，父亲或母亲才能放入水果，所以需要三个量来实现：put,orangeput,appleput。
3、对于互斥操作要一定是先P再V，将它夹在中间。对于同步操作，则是要使用的量，就P操作减一。对于可收回的量，就V操作加一。