PYTHON线程和线程池

进程：运行中的程序

线程：一个进程会默认启动一个线程(线程属于进程)，这个线程是默认的主线程

线程应用：

• 驱动程序：让计算机硬件正常工作
• 操作系统：让硬件之间相互配合，让应用工作
• 应用程序：提供各种功能的软件，一般运行在操作系统上

线程的实现

标准库：_thread和threading，其中 threading 实现了对 _thread的封装

threading模块中提供了Thread , Lock , RLock , Condition等组件

主线程 : 当一个程序启动时 , 就有一个线程开始运行 , 该线程通常叫做程序的主线程

子线程 : 因为程序是开始时就执行的 , 如果你需要再创建线程 , 那么创建的线程就是这个主线程的子线程

主线程的重要性体现在两方面 :

1. 是产生其他子线程的线程

2. 通常它必须最后完成执行比如执行各种关闭操作

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('全部任务完成')