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

# 导入和线程、时间有关的包
import threading
import time


s1 = 0
# 1：售票员通知司机可以开车，0：司机通知售票员不能开门
s2 = 0
# 1：司机通知售票员可以开门，0：售票员通知司机不能开车


class Driver(object):
	"""司机类"""
	# 司机执行的程序
	def drive(self):
		while True:
			self.v()
			time.sleep(1)
			self.p()
			time.sleep(1)

	# 申请信号量s1
	def p(self):
		global s1

		while s1 != 1:
			time.sleep(0.5)
		time.sleep(0.5)
		s1 -= 1
		print('{}  司 机-汽车启动！'.format(time.ctime()))

	# 释放信号量s2
	def v(self):
		global s2

		while s2 != 0:
			time.sleep(0.5)
		time.sleep(0.5)
		s2 += 1
		print('{}  司 机-到站！'.format(time.ctime()))


class Conductor(object):
	"""售票员类"""

	def sellTicket(self):
		while True:
			self.p()
			time.sleep(1)
			self.v()
			time.sleep(1)

	# 申请信号量s2
	def p(self):
		global s2

		while s2 != 1:
			time.sleep(0.5)
		time.sleep(0.5)
		s2 -= 1
		print('{}  售票员-开车门！'.format(time.ctime()))

	# 释放信号量s1
	def v(self):
		global s1

		while s1 != 0:
			time.sleep(0.5)
		time.sleep(0.5)
		s1 += 1
		print('{}  售票员-关车门！'.format(time.ctime()))


if __name__ == '__main__':
	# 实例化司机类
	driver = Driver()
	# 实例化售票员类
	conductor = Conductor()
	# 创建司机执行的线程
	t1 = threading.Thread(target=driver.drive)
	# 创建售票员执行的线程
	t2 = threading.Thread(target=conductor.sellTicket)
	# 线程启动
	t1.start()
	t2.start()

  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

# 导入和线程、时间、随机数有关的包
import threading
import time
import random


class Cumputer(object):
	"""docstring for Cumputer"""
	def __init__(self):
		# Partition status table--分区状态表
		self.tablelist = []
		# 包含要存放的分区的列表
		self.runlist = []
		# 包含暂时无法存放的分区的列表
		self.waitlist = []

	# 初始化分区状态表
	def inittablelist(self):
		# ordinary number--序号
		# 特别说明：假设第一块为系统所用分区，不可用于分配空间
		on = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
		# 各个分区的大小
		size = [10, 20, 20, 20, 40, 40, 40, 100, 100, 200]
		# start address--分区起始地址
		sa = [0, 10, 30, 50, 70, 110, 150, 190, 290, 390]
		# 该分区是否可用的标志
		flag = [False, True, True, True, True, True, True, True, True, True, ]

		# 将每个分区的属性写成分区表动态表
		for i in on:
			temp_dic = {
				'on': i,
				'size': size[i],
				'sa': sa[i],
				'flag': flag[i],
			}
			self.tablelist.append(temp_dic)

	# 主程序
	def running(self):
		# 首先初始化分区状态表
		self.inittablelist()

		# 假设需要分配10个空间
		for i in range(5):
			# 创建对应线程
			self.runlist.append(threading.Thread(target=self.work, args=(random.randint(1, 20) * 10, )))
		# 每个进程开始执行
		for i in self.runlist:
			i.start()
		# 所有进程执行后才继续主线程
		for i in self.runlist:
			i.join()

		# 当等待分配列表里还有成员时一直循环
		while len(self.waitlist) != 0:
			# 清空运行列表
			self.runlist = []
			# 为等待列表里的成员创建线程和启动线程
			for i in range(len(self.waitlist)):
				self.runlist.append(threading.Thread(target=self.work, args=(self.waitlist[0],)))
				self.waitlist.pop(0)
			for i in self.runlist:
				i.start()
			for i in self.runlist:
				i.join()

	# 线程函数
	def work(self, given_size):
		# result存放查找的结果
		result = self.find_a_place(given_size)
		# 若找到一个可用的分区
		if result[0] == 1:
			print('{}  {}工作已分配--{}'.format(time.ctime(), given_size, self.tablelist[result[1]]))
		# 若没有找到则将所需空间加入到等待列表
		else:
			print('{}  {}错误！没有空间存放！'.format(time.ctime(), given_size))
			self.waitlist.append(given_size)
			return 0

		# 模拟占用分区的时间
		time.sleep(random.randint(2, 4))

		# 释放分区
		self.release_the_place(result[1])
		print('{}  {}空间已释放！'.format(time.ctime(), given_size))

	# 查找有没有课分配的分区
	def find_a_place(self, given_size):
		for i in self.tablelist:
			with threading.Lock():
				# 查找比所需分区大且可以被使用的分区
				if given_size <= i['size'] and i['flag']:
					# 更改标志表示已被使用
					i['flag'] = False
					# 成功则返回1和序号
					return [1, i['on']]
		# 失败则返回0和-1
		return [0, -1]

	# 释放已占用的分区
	def release_the_place(self, given_on):
		with threading.Lock():
			# 更改标志后该分区又可被使用
			self.tablelist[given_on]['flag'] = True
		return 1

if __name__ == '__main__':
	# 实例化计算机类并执行程序
	cumputer = Cumputer()
	cumputer.running()