https://www.cnblogs.com/jiyu-hlzy/p/15948408.html
单进程单线程
import time
def production():
"""
间隔一秒,模拟一秒生产一个任务,生产10个任务
:return: 生产完毕,返回需要消费的任务
"""
_tasks = 0
while _tasks < 10:
time.sleep(1)
_tasks += 1
print(f"生产任务:{_tasks}")
return _tasks
def consumption(_tasks, _count):
"""
间隔一秒,模拟一秒消费完一个任务
:param _tasks: 需要消费的任务数
:param _count: 已经消费的任务数
:return:
"""
while _tasks:
time.sleep(1)
_tasks -= 1
_count += 1
print(f"完成任务:{_count} \t\t\t 剩余任务:{_tasks}")
if __name__ == '__main__':
# 已经消费的任务数
finishedTasks = 0
# 生产任务
numberOfTasks = production()
# 消费任务
consumption(numberOfTasks, finishedTasks)
单进程多线程
import time
from queue import Queue
from threading import Thread, current_thread
def production(_task_queue: Queue):
"""
间隔一秒,模拟一秒生产一个任务
一直生产任务
:param: _task_queue
"""
while True:
time.sleep(1)
_task_queue.put(1)
print(f"生产任务:{_task_queue.qsize()} \t\t\t 线程名称:{current_thread().name}\n")
def consumption(_task_queue: Queue, _count_queue: Queue):
"""
间隔一秒,模拟一秒消费完一个任务
只要任务队列中有任务就一直消费
:param _task_queue: 需要消费的任务数
:param _count_queue: 已经消费的任务数
"""
while True:
if _task_queue.qsize():
time.sleep(1)
_task_queue.get()
_count_queue.put(1)
print(f"完成任务:{_count_queue.qsize()} \t\t\t 剩余任务:{_task_queue.qsize()} \t\t\t 线程名称:{current_thread().name}\n")
else:
# 队列中没任务的时候,间隔一段时间后,再继续
print(f'所有任务消费完毕,休息一段时间,等待生产 \t\t 线程名称:{current_thread().name}\n')
time.sleep(10)
if __name__ == '__main__':
"""
线程间通信 用 queue.Queue 队列
传参 args 传递的是元组
只传一个参数时:args = (参数1,)
"""
# 生产 队列
tasksQueue = Queue()
# 已经执行的任务数
ftQueue = Queue()
# 3个线程生产任务
for i in range(1, 4):
t = Thread(target=production, args=(tasksQueue,), name=f'生产线程{i}')
t.start()
# 5个线程消费任务
for i in range(1, 6):
t = Thread(target=consumption, args=(tasksQueue, ftQueue), name=f'消费线程{i}')
t.start()
多进程单线程
import time
from multiprocessing import Process, current_process, Queue
def production(_task_queue: Queue):
"""
间隔一秒,模拟一秒生产一个任务
一直生产任务
:param: _task_queue
"""
while True:
time.sleep(1)
_task_queue.put(1)
print(f"生产任务:{_task_queue.qsize()} \t\t\t 进程名称:{current_process().name}\n")
def consumption(_task_queue: Queue, _count_queue: Queue):
"""
间隔一秒,模拟一秒消费完一个任务
只要任务队列中有任务就一直消费
:param _task_queue: 需要消费的任务数
:param _count_queue: 已经消费的任务数
"""
while True:
if _task_queue.qsize():
time.sleep(1)
_task_queue.get()
_count_queue.put(1)
print(
f"完成任务:{_count_queue.qsize()} \t\t\t 剩余任务:{_task_queue.qsize()} \t\t\t 进程名称:{current_process().name}\n")
else:
# 队列中没任务的时候,间隔一段时间后,再继续
print(f'所有任务消费完毕,休息一段时间,等待生产 \t\t 进程名称:{current_process().name}\n')
time.sleep(10)
if __name__ == '__main__':
"""
进程间通信 用 multiprocessing.Queue 队列
传参 args 传递的是元组
只传一个参数时:args = (参数1,)
"""
# 生产 队列
tasksQueue = Queue()
# 已经执行的任务数
ftQueue = Queue()
# 2个进程生产任务
for i in range(1, 3):
p = Process(target=production, args=(tasksQueue,), name=f'生产进程{i}')
p.start()
# 3个进程消费任务
for i in range(1, 4):
p = Process(target=consumption, args=(tasksQueue, ftQueue), name=f'消费进程{i}')
p.start()
多进程多线程
import time
from threading import Thread, current_thread
from multiprocessing import Process, current_process, Queue
def production(_task_queue: Queue):
"""
一个进程中,开多个线程进行生产
:param _task_queue: 生产任务 队列
"""
def production_individually():
"""
间隔一秒,模拟一秒生产一个任务
一直生产任务
"""
while True:
time.sleep(1)
_task_queue.put(1)
print(f"生产:{_task_queue.qsize()} \t 进程:{current_process().name} \t 线程:{current_thread().name}\n")
# 每个进程中,3个线程生产
for n in range(1, 4):
t = Thread(target=production_individually, name=f'生产线程{n}')
t.start()
def consumption(_task_queue: Queue, _count_queue: Queue):
"""
一个进程中,开多个线程进行消费
:param _task_queue: 需要消费的任务数
:param _count_queue: 已经消费的任务数
"""
def consumption_individually():
"""
间隔一秒,模拟一秒消费完一个任务
只要任务队列中有任务就一直消费
"""
while True:
if _task_queue.qsize():
time.sleep(1)
_task_queue.get()
_count_queue.put(1)
print(
f"完成:{_count_queue.qsize()} \t 剩余:{_task_queue.qsize()} \t "
f"进程:{current_process().name} \t 线程:{current_thread().name}\n"
)
else:
# 队列中没任务的时候,间隔一段时间后,再继续
print(f'所有任务消费完毕,休息一段时间,等待生产 \t 进程:{current_process().name} \t 线程:{current_thread().name}\n')
time.sleep(10)
# 每个进程中,2个线程消费
for n in range(1, 3):
t = Thread(target=consumption_individually, name=f'消费线程{n}')
t.start()
if __name__ == '__main__':
"""
进程间通信 用 multiprocessing.Queue 队列
传参 args 传递的是元组
只传一个参数时:args = (参数1,)
"""
# 生产 队列
tasksQueue = Queue()
# 已经执行的任务数
ftQueue = Queue()
# 2个进程生产任务
for i in range(1, 3):
p = Process(target=production, args=(tasksQueue,), name=f'生产进程{i}')
p.start()
# 3个进程消费任务
for i in range(1, 4):
p = Process(target=consumption, args=(tasksQueue, ftQueue), name=f'消费进程{i}')
p.start()
标签:__,Queue,task,name,Python,queue,--,任务,多线程
From: https://www.cnblogs.com/realizetomoney/p/16730970.html