python多线程队列两组数据_Python 的多线程(2) - 队列

人总是需要不停的工作的

首先自我介绍一下， 我叫裘千，大家都叫我QQ ,我今天 50 岁了，工作是一个搬尸人，这份工作已经做了10多年，早已经失去了对冰冷尸体的渴望了 。

ps : 为什么是渴望， 谁也不知道 . . .

老周和老L是 枪决执行者， 我就处理他们的尾事，我还有一个同伴，叫AA,因为他永远不会请客，和别人在一起吃永远都是AA制的，

ps : 很奇怪是吧，就是， 做这种工作的 能有几个正常的呢

活来了， 前几天冷冻库里多了几具尸体，有人会把它们搬出来，堆在一起，最后需要我们去他们埋

1. 先把尸体搬出来：

import threading

import time

import queue

import random

## 定义一个死人堆,这一堆只能放 10 个人

pitQueue = queue.Queue(10) # 这是一个队列

threadLock = threading.Lock()

isHasNewPit = True; #是否有新的尸体来了

#定义一个 死人堆，并往死人堆了放尸体，每${sec}秒就堆入一个

def offer(sec):

threadLock.acquire()

i=0

while True:

if i==7:

break

try:

if not pitQueue.full():

deadMans = {'name':'S'+str(i).zfill(3),'age':15+random.choice(range(50))}

time.sleep(sec) # 休眠的描述自己控制下，不然一边堆，一边拖，永远托不完了,会看不出效果

pitQueue.put(deadMans) # 把死刑犯扔里面去

print('堆入{0}成功'.format(deadMans['name']))

i+=1

if i==6:

time.sleep(3)

else:

print('死人堆已经满了，旁边等会或者往别的死人堆里放吧')

break

except e:

print("啊"*6 + "... 尸变啦，快跑啊 ...",e)

break

threadLock.release()

2. 再看下怎么干 好干，和一个休息等待的功能，万一冷冻库你的没搬完呢

# 干活啦 大家都干一样的活，就没必要放类里面了， 把尸体拖入坑中

def consume(li,data):

time.sleep(2) # 这里是真的用了两秒哦

print(" 工作人员{0}，用了{1}秒,将死刑犯编号为：{2}，年龄为{3}的尸体拖入坑中,顺便踩两了脚 ..."

.format(li['wn'],li['de'],data['name'],data['age']))

# 等会吧，万一还有尸体呢 。。。

def waiting(workName):

print("------> 小{0} 回到尸体堆旁，看到尸体堆已经空了， 打算等待5秒钟,如果5秒后没人来，就下班了".format(workName))

for i in range(5):

time.sleep(1)

print('{0}的{1}秒过去了 ...'.format(workName,i))

if pitQueue.empty():

print("5秒钟后，尸体堆还是空的...下班咯， 啦啦啦 ....")

return True

else :

print("5秒钟后，尸体堆怎么还有 啊 ， 他妈的...累死老子了")

return False

3. 再定义一个干活的章程， 还要知道是谁搬的，耗时多久，这些工作信息，总不能都偷懒

#建一个干活线程类，继承 threading.Threadn

class WorkThreadingTest(threading.Thread):

##成员变量

workName='' #工作人员名称

de=0 # 休眠时间 ， 单位秒

# 该类的构造方法

def __init__(self,wn,de):

threading.Thread.__init__(self) # 父类的构造，不同java的语法, 这里如果不写，会报错

self.workName=wn

self.de=de

#run 方法 类似java 的 run()

def run(self):

while True :

if not pitQueue.empty():

data = pitQueue.get()

if data: # 如果尸体对不为空 ，那么一直拖， 直到托完为止

li = {'wn':self.workName,'de':self.de}

consume(li,data)

else:

if waiting(self.workName):

break

else :

if waiting(self.workName):

break

4. 再来一个统一发号命令接受开始干活的入口

# 这个队伍的人陆续开始干活

def main():

# 定义一个拖尸体队伍 ， 六大拖尸体金刚

workTeam = ['QQ','AA']

threads = [] # 所有线程的列表

time.sleep(3)

if not pitQueue.empty(): # 如果大家看到 尸体堆是空的， 就不要去干活啦，

for worker in workTeam:

second = 1 #random.choice(range(5))

thread = WorkThreadingTest(worker,second)

thread.start()

threads.append(thread)

else:

print("ps : 大家看到尸体堆是空的，就坐在旁边打屁吹牛啦，不用起来一个个过去看了 !!! \n")

for t in threads :

t.join()

print("Game over ... \n")

5. 这里有两波人嘛 ，自然有两个入口啦，自然需要两个入口线程了

# 堆尸体 的人 和 拖尸体的队伍 ，应该是独立的个体，是同时干活的，所以开两个线程

# 堆堆堆 。。。

class offerThread(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

offer(1)

# 拖拖拖 。。。

class mainThread(threading.Thread):

def __init__(self):

threading.Thread.__init__(self)

def run(self):

main()

6. 最后才是 发号命令 开始干活 。。。

#调用 主函数main

offthead = offerThread()

mthread = mainThread()

offthead.start()

mthread.start()

7. 最后的输出结果 情况 ：

其实这个 列表对象也能实现队列 。。 。 不过需要自己实现队列阻塞能力，比较复杂，

当然这里并没有体现出阻塞的能力

初学者，如有问题，请不吝指出， 非常感谢  ！！！