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('全部任务完成')
  • 1
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值