Python语言之并发编程
（一）_thread模块实现多线程（已不推荐使用）
- 没有控制进程结束机制
- 只有一个同步原语（锁）
import time
import _thread
def work(n):
print('当前时间开始为：{}'.format(time.ctime()))
time.sleep(n)
print('当前时间结束为为：{}'.format(time.ctime()))
def main():
print('当前时间为：{}'.format(time.ctime()))
_thread.start_new_thread(work,(4,))
_thread.start_new_thread(work,(2,))
time.sleep(6)
print('当前时间结束为：{}'.format(time.ctime()))
if __name__ == '__main__':
main()
（二）threading模块
threading.Thread
import time
import threading
def work(n):
print('当前时间开始为：{}'.format(time.ctime()))
time.sleep(n)
print('当前时间结束为为：{}'.format(time.ctime()))
def main():
print('main开始为：{}'.format(time.ctime()))
threads = []
t1 = threading.Thread(target=work,args=(4,))
t2 = threading.Thread(target=work,args=(2,))
threads.append(t1)
threads.append(t2)
for t in threads:
t.start()
print('main结束为：{}'.format(time.ctime()))
if __name__ == '__main__':
main()
------------------------------------------------------------------------------
main开始为：Tue Jan 14 21:33:42 2020
当前时间开始为：Tue Jan 14 21:33:42 2020
当前时间开始为：Tue Jan 14 21:33:42 2020
main结束为：Tue Jan 14 21:33:42 2020
当前时间结束为为：Tue Jan 14 21:33:44 2020
当前时间结束为为：Tue Jan 14 21:33:46 2020
join()让主线程等待
import threading
def work(n):
print('当前时间开始为：{}'.format(time.ctime()))
time.sleep(n)
print('当前时间结束为为：{}'.format(time.ctime()))
def main():
print('main开始为：{}'.format(time.ctime()))
threads = []
t1 = threading.Thread(target=work,args=(4,))
t2 = threading.Thread(target=work,args=(2,))
threads.append(t1)
threads.append(t2)
for t in threads:
t.start()
for t in threads:
t.join()
print('main结束为：{}'.format(time.ctime()))
if __name__ == '__main__':
main()
-----------------------------------------------------------------
main开始为：Tue Jan 14 21:36:57 2020
当前时间开始为：Tue Jan 14 21:36:57 2020
当前时间开始为：Tue Jan 14 21:36:57 2020
当前时间结束为为：Tue Jan 14 21:36:59 2020
当前时间结束为为：Tue Jan 14 21:37:01 2020
main结束为：Tue Jan 14 21:37:01 2020
自定义Mythread
import time
import threading
class MyThread(threading.Thread):
def __init__(self,func,args):
threading.Thread.__init__(self)
self.func = func
self.args = args
def run(self):
self.func(*self.args)
def work(n):
print('当前时间开始为：{}'.format(time.ctime()))
time.sleep(n)
print('当前时间结束为为：{}'.format(time.ctime()))
def main():
print('main开始为：{}'.format(time.ctime()))
threads = []
t1 = MyThread(work,(4,))
threads.append(t1)
t2 = MyThread(work,(4,))
threads.append(t2)
for t in threads:
t.start()
for t in threads:
t.join()
print('main结束为：{}'.format(time.ctime()))
if __name__ == '__main__':
main()
（三）锁
threading.Lock()
import threading
import time
import random
eggs = []
lock1 = threading.Lock()
def put_egg(n,list):
lock1.acquire()
for i in range(1,n+1):
time.sleep(random.randint(0,2))
list.append(i)
lock1.release()
def main():
threads = []
t1 = threading.Thread(target=put_egg,args=(5,eggs))
threads.append(t1)
t2 = threading.Thread(target=put_egg,args=(5,eggs))
threads.append(t2)
for t in threads:
t.start()
for t in threads:
t.join()
print(eggs)
if __name__ == '__main__':
main()
-------------------------------------------------------------
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
with语法
def put_egg(n,list):
with lock1:
for i in range(1, n + 1):
time.sleep(random.randint(0, 2))
list.append(i)
（四）队列
- Queue FIFO
- LifoQueue LIFO
- PriorityQueue 优先队列
import threading
import queue
import time
import random
def producer(data_queue):
for i in range(5):
time.sleep(0.5)
item = random.randint(0, 100)
data_queue.put(item)
print(f'{threading.current_thread().name}在队列中放入数据项{item}')
def consumer(data_queue):
while True:
try:
item = data_queue.get(timeout=3)
print(f'{threading.current_thread().name}在队列中移除了数据项{item}')
except queue.Empty:
break
else:
data_queue.task_done()
def main():
q = queue.Queue()
threads = []
producer1 = threading.Thread(target=producer, args=(q,))
producer1.start()
for i in range(2):
c = threading.Thread(target=consumer, args=(q,))
threads.append(c)
for t in threads:
t.start()
for t in threads:
t.join()
#队列所有项处理完毕前阻塞
q.join()
if __name__ == '__main__':
main()
（五）多进程模块
IO密集型采用多线程，cpu密集型可采用多进程
import time
import multiprocessing
def fun(n):
print(f'{multiprocessing.current_process().name} 执行开始于：{time.ctime()}')
time.sleep(n)
print(f'{multiprocessing.current_process().name} 执行结束于：{time.ctime()}')
def main():
print(f'主函数运行于：{time.ctime()}')
processes = []
p1 = multiprocessing.Process(target=fun,args=(4,))
processes.append(p1)
p2 = multiprocessing.Process(target=fun,args=(4,))
processes.append(p2)
for i in processes:
i.start()
for i in processes:
i.join()
print(f'主函数结束于：{time.ctime()}')
if __name__ == '__main__':
main()
（六）concurrent.futures模块
- ThreadPoolExecutor 多线程
- ProcessPoolExecutor 多进程
import concurrent.futures
def work(i):
print(i)
def fun1():
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
executor.submit(work, 5)
def fun2():
with concurrent.futures.ProcessPoolExecutor(max_workers=5) as executor:
executor.submit(work, 5)
