操作系统实验一：并发程序设计

一、实验目的

（1）加深对进程并发执行的理解，认识多进程并发执行的实质。

（2）观察进程共享资源的现象，学习解决进程互斥和同步的方法。

 

二、实验要求：

本实验要求用高级语言，启动多进程并发运行，设计相应代码，显示进程无关并发、进程共享变量并发的运行结果。并完成实验报告。

  

三、实验内容：

分别实现以下四种情况的并发：

1.并发的进程之间无关，显示进程名称，开始与结束时间。

模拟多终端售票情况，并发的多个终端进程之间共享剩余票数这个共享变量。

2.用全局变量实现。

3.用进程间共享数据机制实现。

4.用进程间共享数据机制和加锁机制实现。

 

四、实验过程与结果

1. 算法思想与设计
2. 算法实现代码
3. 运行结果

1.1

 1.2 算法实现代码

#无关变量
import time
import random
from multiprocessing import Process

def f(name):
    print('%s processing' % name)
    time.sleep(random.randrange(2, 5))
    print('%s end' % name)

if __name__ == '__main__':
    p1 = Process(target=f, args=('a',))
    p2 = Process(target=f, args=('b',))
    p3 = Process(target=f, args=('c',))
    p4 = Process(target=f, args=('d',))


    p1.start()
    p2.start()
    p3.start()
    p4.start()

1.3 运行结果

a processing
b processing
c processing
d processing
a end
c end
b end
d end

2.1 算法思想与设计

 

2.2 算法实现代码

from multiprocessing import Process
def f(dic):
    dic['count'] -= 1
    print(dic)


if __name__ == '__main__':
    dic = {'count': 10}
    p_list = []
    for i in range(5):
        p = Process(target=f, args=(dic,))
        p.start()
        p_list.append(p)
    for i in p_list:i.join()
    print('主进程',dic)

2.3 运行结果

{'count': 9}
{'count': 9}
{'count': 9}
{'count': 9}
{'count': 9}
主进程 {'count': 10}

3.1 算法思想与设计

 

3.2 算法实现代码

#共享变量
from multiprocessing import Process,Manager
def f(dic,name):
    dic['count'] -=1
    print(name,dic)

if __name__ == '__main__':
    m = Manager()
    dic = m.dict({'count':10})
    p_list = []
    for i in range(5):
        p = Process(target=f, args=(dic,'进程%s'%i,))
        p.start()
        p_list.append(p)
    for i in p_list:
        i.join()
    print('主进程',dic)

3.3 运行结果

进程0 {'count': 9}
进程1 {'count': 8}
进程2 {'count': 7}
进程3 {'count': 6}
进程4 {'count': 5}
主进程 {'count': 5}

4.1 算法思想与设计

 

4.2 算法实现代码

#共享变量，加锁
import threading
from multiprocessing import Process, Manager, Lock
def f(dic,name,lock):
    lock = threading.Lock()  # lock对象
    lock.acquire()
    dic['count'] -= 1
    print(name, dic)
    lock.release()

if __name__ == '__main__':
    m = Manager()
    lck = Lock()
    dic = m.dict({'count': 10})
    p_list = []
    for i in range(5):
        p = Process(target=f, args=(dic, lck, '进程%s' % i,))
        p.start()
        p_list.append(p)
    for i in p_list:
        i.join()
    print('主进程', dic)

4.3 运行结果

<Lock(owner=None)> {'count': 9}
<Lock(owner=None)> {'count': 8}
<Lock(owner=None)> {'count': 7}
<Lock(owner=None)> {'count': 6}
<Lock(owner=None)> {'count': 5}
主进程 {'count': 5}