线程和线程池
进程:运行中的程序
线程:一个进程会默认启动一个线程(线程属于进程),这个线程是默认的主线程
线程应用:
- 驱动程序:让计算机硬件正常工作
- 操作系统:让硬件之间相互配合,让应用工作
- 应用程序:提供各种功能的软件,一般运行在操作系统上
线程的实现
标准库:_thread和threading,其中 threading 实现了对 _thread的封装
threading模块中提供了Thread , Lock , RLock , Condition等组件
主线程 : 当一个程序启动时 , 就有一个线程开始运行 , 该线程通常叫做程序的主线程
子线程 : 因为程序是开始时就执行的 , 如果你需要再创建线程 , 那么创建的线程就是这个主线程的子线程
主线程的重要性体现在两方面 :
是产生其他子线程的线程
通常它必须最后完成执行比如执行各种关闭操作
Thread类
常用参数说明
参数 | 说明 |
---|---|
target | 表示调用的对象,即子线程要执行的任务 |
name | 子线程名称 |
args | 传入target函数中的位置参数,是一个元组,参数后必须加逗号 |
使用如下
#导入包
from threading import Thread
#调用对象
def funa():
pass
#实例化对象,创建线程
my_thread = Thread(target = funa)
#线程运行
my_thread.start()
常用方法
方法名 | 描述 |
---|---|
Thread.run(self) | 线程启动时运行的方法,由该方法调用target参数所指定的函数 |
Thread.start(self) | 启动进程,start方法就是去帮你调用run方法 |
Thread.terminate(self) | 强制终止线程 |
Thread.join(self,timeout=None) | 阻塞调用,主线程进行等待 |
Thread.setDaemon(self,daemonic) | 将子线程设置为守护线程 |
Thread.getName(self,name) | 获取线程名称 |
Thread.setName(self,name) | 设置线程名称 |
示例如下
import threading
import time
#定义线程要运行的函数
def funa(name,a):
#休眠一段时间便于观察
time.sleep(a)
print('我是{}'.format(name))
#创建两个线程
my_ti1 = threading.Thread(target=funa,args=('yuxuan',3))
my_ti2 = threading.Thread(target=funa,args=('fashi',4))
#设置守护线程,守护线程需要在启动线程之前设置
my_ti1.Daemon(True)
#如果设置了子线程为守护线程,那么子线程的一切以主线程为主,即如果主线程还杂执行,那么子线程也会继续执行,如果主线程已经执行完毕,即使子线程未执行完毕,子线程也会结束
#启动线程
my_ti1.start()
my_ti2.start()
#线程阻塞,主线程等待子线程my_ti2执行完毕再继续执行
my_ti2.join()
#设置线程名称
my_ti2.setName('jiucheng')
#获得线程名称
my_ti2.getName()
通过继承来实现多线程
import threading
import time
#继承 threading中的Thread类
class MyThread(threading.Thread):
#参数通过__init__来初始化
def __init__(self,name):
super().__init__()
self.name = name
#重写run方法,这个是表示线程活动的方法,必须有
def run(self):
#以下写上需要实现的方法
print('my name is {}'.foramt(self.name))
time.sleep(2)
if __name__ == '__main__':
#创建线程实例
my_t1 = MyThread('t1')
my_t2 = MyThread('t2')
#启动线程
my_t1.start()
my_t2.start()
如果重写的run方法有参数,那么需要通过___init__方法对参数初始化,如果要使用父类的init方法,加上super().__init__()
线程之间的通讯
在多线程中 , 所有变量对于所有线程都是共享的 , 因此 , 线程之间共享数据最大的危险在于多个线程同时修改一个变量 , 那就乱套了 , 所以我们需要互斥锁 , 来锁住数据。
如下示例
import threading
import time
#定义全局变量a
a = 1
#定义线程要运行的函数
def funa():
#使用全局变量
global a
for i in range(1000):
a+=1
def funb():
#使用全局变量
global a
for i in range(1000):
a+=2
#创建线程
t1 = threading.Thread(target=funa)
t2 = threading.Thread(target=funb)
#启动线程
t1.start()
t2.start()
上述的示例因为没有加线程锁,当两个线程在执行的过程中会产生竞争,从而不确定哪个线程来执行函数。
所以为了避免对全局变量a的修改出现问题,当需要修改数据a时加上锁。
当一个线程正在访问a时,其他线程会等待当前线程对a的访问完毕,并且解锁,然后实行对a的访问。
加锁 lock.acquire
互斥锁:在多线程中 , 所有变量对于所有线程都是共享的 , 因此 , 线程之间共享数据最大的危险在于多个线程同时修改一个变量 , 那就乱套了 , 所以我们需要互斥锁 , 来锁住数据。
所以上述代码改进如下
from threading import Thread,Lock
#定义全局变量a
a = 1
#锁实例化
lock = Lock()
第一种实现
#定义线程要运行的函数
def funa():
#使用全局变量
global a
for i in range(1000):
#访问a前加锁
lock.acquire()
a+=1
#访问a完毕解锁
lock.release()
def funb():
#使用全局变量
global a
for i in range(1000):
#访问a前加锁
lock.acquire()
a+=2
#访问a完毕解锁
lock.release()
#创建线程
t1 = Thread(target=funa)
t2 = Thread(target=funb)
#启动线程
t1.start()
t2.start()
#阻塞主线程
t1.join()
t2.join()
第二种实现
#定义线程要运行的函数
def funa():
#使用全局变量
global a
for i in range(1000):
#访问a前加锁,with在对a的访问完毕后会自动解锁
with lock:
a+=1
def funb():
#使用全局变量
global a
for i in range(1000):
#访问a前加锁,with在对a的访问完毕后会自动解锁
with lock:
a+=2
#创建线程
t1 = Thread(target=funa)
t2 = Thread(target=funb)
#启动线程
t1.start()
t2.start()
#阻塞主线程
t1.join()
t2.join()
线程队列
队列的概念:一个入口,一个出口,先入先出(FIFO)(单项队列)
队列需要导包
from queue import Queue
队列常见方法
方法名 | 描述 |
---|---|
put(item) | 入队 |
get() | 出队 |
empty()#近似 | 测试队列是否为空 |
full()#近似 | 测试队列是否为满 |
qsize()#近似 | 队列长度 |
task_done() | 任务结束 |
join() | 等待完成 |
一个队列的简单实现
from threading import Thread
from queue import Queue
#产生随机数的包
from random import randint
#创建队列对象,队列长度为10
my_q = Queue(10)
#生产数据
def put_Data(my_q):
for i in range(10):
#产生0-1000之间的随机数
num = randin(0,1000)
#往队列放数据
my_q.put(num)
#取出数据
def get_Data(my_q):
for i in range(10):
#从队列取出数据
my_q.get()
#创建两个线程,分别用来生成数据和取出数据
t1 = Thread(target=put_Data,args=(my_q,))
t2 = Thread(target=get_Data,args=(my_q,))
#线程启动
t1.start()
t2.start()
#阻塞主线程
t1.join()
t2.join()
通过队列一边生产数据,一边取出数据,取数据时不会对数据产生影响,相当于变相实现了锁的功能,因为队列是一边进,一边出,对于没有入队的数据不会取到,所以保证了数据的安全。
from queue import Queue
#产生随机数的包
from random import randint
#创建队列对象,队列长度为10
my_q = Queue(10)
#生产数据
def put_Data(my_q):
for i in range(10):
#产生0-1000之间的随机数
num = randin(0,1000)
#往队列放数据
my_q.put(num)
#得到队列有多少数据,并不是队列的总大小
my_q.qsize()
#put相当于一个任务,当put完成时,需要加上task_done(),put一次就需要task_done()一次
my_q.put(1)
my_q.task_done()
#join是检测任务是否完成,例如如果put了10次,但是task_done()只有9次,那么join()会等待最后一个task_done()完成才会执行,否则会产生阻塞
my_q.join()
线程池
若干个线程等待被使用,当需要使用时,去除线程,使用完一个线程,再次放入线程池中,当代下次使用,达到循环使用线程的目的。
主线程: 相当于生产者,只管向线程池提交任务。
并不关心线程池是如何执行任务的。
因此,并不关心是哪一个线程执行的这个任务。
线程池: 相当于消费者,负责接收任务,
并将任务分配到一个空闲的线程中去执行。
一个线程池的简单实现
#导入包,配合队列实现线程池
from threading import Thread
from queue import Queue
class ThreadPool:
#线程池初始化
def __init__(self,n): #n 线程的数量
self.queue = Queue() #放任务的队列
for i in range(n):
#创建线程,self.worker线程执行的函数,并指定线程为守护线程
Thread(target=self.worker,daemon=True).start()
#线程执行的函数,即用来执行任务函数的函数
def worker(self):
while True:
#从队列中取任务func表示任务函数,args,kwargs是任务函数的参数
func,args,kwargs = self.queue.get()
#任务函数,执行此函数完成一系列功能
func(*args,**kwargs)
#任务函数执行完毕,表示队列的get()任务完成,需要task_done()表示任务完成
self.queue.task_done()
#往队列中放任务函数,参数func 表示任务函数,args和kwargs表示任务函数参数
def apply_async(self,func,args=(),kwargs={}):
#往队列中放任务
self.queue.put((func,args,kwargs))
#用来判断队列中的所有任务是否完成
#worker中任务函数执行完一次就会task_done(),如果有10次任务,task_done()次数不够10次,那么join不会执行
def join(self):
#用来判断队列任务是否执行完毕
self.queue.join()
初始化函数:用来指定线程池内可以使用的线程的数量。
工作函数:从队列中取出任务分配给线程使用,然后执行任务函数,执行完通知队列任务执行完毕。
队列放任务函数:实现往队列中添加任务函数
阻塞函数:等待队列中所有的任务执行完毕,用来判断是否有任务未执行完毕
效果演示
#接上述代码
#任务函数1
def task1():
time.sleep(2)
print('任务1完成')
#任务函数2
def task1(*args,**kwargs):
time.sleep(2)
print('任务2完成',args,kwargs)
#线程池实例化,2表示有两个线程
my_pool = ThreadPool(2)
#放任务
my_pool.apply_async(task1)
my_pool.apply_async(task2,args=(1,2),kwargs={'name':'jiucheng','age':18})
#任务放置完成
print('任务放置完成')
#判断任务是否执行完成
my_pool.join()
#如果执行完成,会执行以下代码
print('全部任务完成')
python内置线程池
代码演示如下
#导包
from multiprocessing.pool import ThreadPool
import time
#内置线程池实例化,2表示有两个线程
my_pool = ThreadPool(2)
#任务函数1
def task1():
time.sleep(2)
print('任务1完成')
#任务函数2
def task2(*args,**kwargs):
time.sleep(2)
print('任务2完成',args,kwargs)
#放任务
my_pool.apply_async(task1)
my_pool.apply_async(task2,args=(1,2),kwds={'name':'yuxuan','age':15})
#任务放置完成
print('任务放置完成')
#要求,在join前必须要close,表示这样就不允许再提交其他任务了
my_pool.close()
#判断任务是否执行完成
my_pool.join()
#如果执行完成,会执行以下代码
print('全部任务完成')