threading线程及线程池

柔光的暖阳◎ 2022-02-21 05:14 354阅读 0赞

**threading中的setDaemon()：**

import time
    import threading									#线程模块
    
    def sub(i):
    	print('子线程开始...')
    	time.sleep(1)
    	print(i)
    	print('子线程结束！')
    
    def main():
    	print('主线程开始...')
    	start = time.time()
    	#使用线程
    	for i in range(5):								#开启5个线程
    		# 第一个参数target是线程调用函数，第二个参数args是一个数组变量，用于给worker函数传参，有几个参数就写几个，用","分割，最后的逗号不能少，少了就不是数组了，就会出错。
    		th = threading.Thread(target=sub, args=(i,))
    		th.setDaemon(True)							#设置守护进程
    		th.start()
    	end = time.time()
    	print("总运行时长：%s秒" % (end-start))
    	print('主线程结束！')
    
    if __name__ == "__main__":
    	main()

设置setDaemon()时，结果如下：

主线程开始...
    子线程开始...
    子线程开始...
    子线程开始...
    子线程开始...
    子线程开始...
    总运行时长：0.002000093460083008秒
    主线程结束！

主线程结束后，子线程没有继续执行。  
setDaemon()注释掉时，结果如下：

主线程开始...
    子线程开始...
    子线程开始...
    子线程开始...
    子线程开始...
    子线程开始...
    总运行时长：0.005000114440917969秒
    主线程结束！
    0
    子线程结束！
    1
    子线程结束！
    3
    子线程结束！
    2
    子线程结束！
    4
    子线程结束！

主线程结束后，子线程继续执行。  
**结论：**  
若setDaemon()的参数为True，主线程结束且子线程尚未结束，则子线程也一并结束；  
若setDaemon()的参数为False(默认值)，主线程结束且子线程尚未结束，则子线程继续执行。  
**注意：**  
setDaemon()必须设置在start()之前才有效。

**threading中的join()：**  
join的作用就是检测子线程是否结束，没有结束就阻塞，直到子线程结束才接着执行下面的程序。

from time import sleep
    from threading import Thread
    
    def sub():
    	print('子线程开始...')
    	for i in range(10):
    		print(i)
    		sleep(1)
    	print('子线程结束！')
    
    def main():
    	print('主线程开始...')
    	c = Thread(target=sub)
    	c.start()
    	c.join()										#阻塞，直到线程结束才执行下面的程序
    	print('主线程结束！')
    
    if __name__ == '__main__':
    	main()

有c.join()时，结果如下：

主线程开始...
    子线程开始...
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    子线程结束！
    主线程结束！

c.join()注释掉时，结果如下：

主线程开始...
    子线程开始...
    0
    主线程结束！
    1
    2
    3
    4
    5
    6
    7
    8
    9
    子线程结束！

**线程池：**

import concurrent.futures
    import time
    
    def func(n):
    	print('%d\n' % n)
    	c = 0
    	for i in range(3):
    		c += 1
    		print(c)
    	time.sleep(1)

**submit()方法：**

def start_thread_pool():
    	pool = concurrent.futures.ThreadPoolExecutor(2)		#创建一个总线程数为2的线程池
    	li = [0, 1, 2, 3, 4]								#创建待执行线程(5个)
    	for n in li:										#在循环中每次取出一个线程来执行func函数，线程池没有空闲线程时则会进入等待。
    		pool.submit(func, n)							
    
    if __name__ == '__main__':
    	start_thread_pool()
    	print("已全部完成")

结果为：

0
    
    1
    2
    3
    1
    已全部完成
    
    1
    2
    3
    2
    
    1
    2
    3
    3
    
    1
    2
    3
    4
    
    1
    2
    3

**map()方法：**

def start_thread_pool():
    	pool = concurrent.futures.ThreadPoolExecutor(2)		#创建一个总线程数为2的线程池
    	li = [0, 1, 2, 3, 4]								#创建待执行线程(5个)
    	pool.map(func, li)									
    
    if __name__ == '__main__':
    	start_thread_pool()
    	print("已全部完成")

结果为：

0
    
    1
    2
    3
    1
    已全部完成
    
    1
    2
    3
    2
    
    1
    2
    3
    3
    
    1
    2
    3
    4
    
    1
    2
    3

**wait()方法：**

def start_thread_pool():
    	pool = concurrent.futures.ThreadPoolExecutor(2)		#创建一个总线程数为2的线程池
    	li = [0, 1, 2, 3, 4]								#创建待执行线程(5个)
    	main = [pool.submit(func, n) for n in li]			#必须为submit()
    	concurrent.futures.wait(main)						#等待条件默认为return_when='ALL_COMPLETED'，等待所有任务都结束再继续执行下面的代码
    
    if __name__ == '__main__':
    	start_thread_pool()
    	print("已全部完成")

结果为：

0
    
    1
    2
    3
    1
    
    1
    2
    3
    2
    
    1
    2
    3
    3
    
    1
    2
    3
    4
    
    1
    2
    3
    已全部完成