文章目录
- 线程Thread
- 创建方式
- join()
- 守护线程
- 全局锁GIL问题
- 线程同步和互斥锁
- 死锁
- 信号量
- 事件(Event)
- 生产者和消费者模式
线程Thread
创建方式
Python的标准库提供了两个模块： _thread 和threading ， _thread 是低级模块， threading 是高级模块，对_thread 进行了封装。绝大多数情况下，我们只需要使用threading 这个高级模块。线程的创建可以通过分为两种方式：
1. 方法包装
2. 类包装
线程的执行统一通过start() 方法
线程的创建方式(方法包装)
#encoding=utf-8
#方法方式创建线程
from threading import Thread
from time import sleep
def func1(name):
for i in range(3):
print(f"thread:{name} :{i}")
sleep(1)
if __name__ == '__main__':
print("主线程，start")
#创建线程
t1 = Thread(target=func1,args=("t1",))
t2 = Thread(target=func1,args=("t2",))
#启动线程
t1.start()
t2.start()
主线程，start
thread:t1 :0
thread:t2 :0
thread:t1 :1
thread:t2 :1
thread:t1 :2thread:t2 :2
线程的创建方式(类包装)
#encoding=utf-8
#类的方式创建线程
from threading import Thread
from time import sleep
class MyThread(Thread):
def __init__(self,name):
Thread.__init__(self)
self.name =name
def run(self):
for i in range(3):
print(f"thread:{self.name} :{i}")
sleep(1)
if __name__ == '__main__':
print("主线程，start")
#创建线程(类的方式)
t1 = MyThread('t1')
t2 = MyThread('t2')
#启动线程
t1.start()
t2.start()
print("主线程，end")
主线程，start
thread:t1 :0
thread:t2 :0
主线程，end
thread:t2 :1thread:t1 :1
thread:t2 :2thread:t1 :2
join()
之前的代码，主线程不会等待子线程结束。如果需要等待子线程结束后，再结束主线程，可使用join()方法。
#encoding=utf-8
from threading import Thread
from time import sleep
def func1(name):
for i in range(3):
print(f"thread:{name} :{i}")
sleep(1)
if __name__ == '__main__':
print("主线程，start")
#创建线程
t1 = Thread(target=func1,args=("t1",))
t2 = Thread(target=func1,args=("t2",))
#启动线程
t1.start()
t2.start()
#主线程会等待t1,t2结束后，再往下执行
t1.join()
t2.join()
print("主线程，end")
主线程，start
thread:t1 :0
thread:t2 :0
thread:t2 :1thread:t1 :1
thread:t1 :2thread:t2 :2
主线程，end
守护线程
在行为上还有一种叫守护线程，主要的特征是它的生命周期。主线程死亡，它也就随之死亡。在python中，线程通过setDaemon(True|False)来设置是否为守护线程。守护线程的作用：为其他线程提供便利服务，守护线程最典型的应用就是 GC (垃圾收集器)。
#encoding=utf-8
from threading import Thread
from time import sleep
class MyThread(Thread):
def __init__(self,name):
Thread.__init__(self)
self.name =name
def run(self):
for i in range(3):
print(f"thread:{self.name}:{i}")
sleep(1)
if __name__ == '__main__':
print("主线程，start")
#创建线程(类的方式)
t1 = MyThread('t1')
#t1设置为守护线程
t1.daemon=True #t1.setDaemon(True)#3.10后被废弃，可以直接 t1.daemon=True
#启动线程
t1.start()
print("主线程，end")
主线程，start
thread:t1:0
主线程，end
thread:t1:1
thread:t1:2
全局锁GIL问题
在python中，无论你有多少核，在Cpython解释器中永远都是假象。无论你是4核，8核，还是16核…不好意思，同一时间执行的线程只有一个线程，它就是这个样子的。这个是python的一个开发时候，设计的一个缺陷，所以说python中的线程是“含有水分的线程”。
Python代码的执行由Python 虚拟机(也叫解释器主循环，CPython版本)来控制，Python 在设计之初就考虑到要在解释器的主循环中，同时只有一个线程在执行，即在任意时刻，只有一个线程在解释器中运行。对Python 虚拟机的访问由全局解释器锁（GIL）来控制，正是这个锁能保证同一时刻只有一个线程在运行。
GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念,同样一段代码可以通过CPython，PyPy，Psyco等不同的Python执行环境来执行,就没有GIL的问题。然而因为CPython是大部分环境下默认的Python执行环境。所以在很多人的概念里CPython就是Python，也就想当然的把GIL归结为Python语言的缺陷
线程同步和互斥锁
处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。 这时候，我们就需要用到“线程同步”。 线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面的线程使用完毕后，下一个线程再使用。
【示例】多线程操作同一个对象(未使用线程同步) 模拟取钱
# -*- coding: utf-8 -*-
from threading import Thread
from time import sleep
class Account:
def __init__(self,money,name):
self.money = money
self.name = name
#模拟提款操作
class Drawing(Thread):
def __init__(self,drawingNum,account):
Thread.__init__(self)
self.drawingNum = drawingNum
self.account = account
self.expenseTotal = 0
def run(self):
if self.account.money-self.drawingNum < 0:
return
sleep(1) #判断完后阻塞。其他线程开始运行。
self.account.money -= self.drawingNum;
self.expenseTotal += self.drawingNum;
print(f"账户：{self.account.name},余额是：{self.account.money}")
print(f"账户：{self.account.name},总共取了：{self.expenseTotal}")
if __name__ == '__main__':
a1 = Account(100,"zhangsan")
draw1 = Drawing(80,a1) #定义取钱线程对象；
draw2 = Drawing(80,a1) #定义取钱线程对象；
draw1.start() #你取钱
draw2.start() #你老婆取钱
账户：zhangsan,余额是：20账户：zhangsan,余额是：-60
账户：zhangsan,总共取了：80
账户：zhangsan,总共取了：80
没有线程同步机制，两个线程同时操作同一个账户对象，竟然从只有100元的账户，轻松取出80*2=160元，账户余额竟然成为了-60。这么大的问题，显然银行不会答应的。
我们可以通过“锁机制”来实现线程同步问题，锁机制有如下几个要点：
1 必须使用同一个锁对象
2 互斥锁的作用就是保证同一时刻只能有一个线程去操作共享数据，保证共享数据不会出现错误问题
3 使用互斥锁的好处确保某段关键代码只能由一个线程从头到尾完整地去执行
4 使用互斥锁会影响代码的执行效率
5 同时持有多把锁，容易出现死锁的情况
互斥锁: 对共享数据进行锁定，保证同一时刻只能有一个线程去操作。
注意: 互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁。
threading 模块中定义了Lock 变量，这个变量本质上是一个函数，通过调用这个函数可以获取一把互斥锁。
【示例】多线程操作同一个对象(增加互斥锁，使用线程同步)
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 20 09:20:33 2024
@author: Administrator
"""
#encoding=utf-8
from threading import Thread,Lock
from time import sleep
class Account:
def __init__(self,money,name):
self.money = money
self.name = name
#模拟提款操作
class Drawing(Thread):
def __init__(self,drawingNum,account):
Thread.__init__(self)
self.drawingNum = drawingNum
self.account = account
self.expenseTotal = 0
def run(self):
lock1.acquire()
if self.account.money-self.drawingNum < 0:
return
sleep(1) #判断完后阻塞。其他线程开始运行。
self.account.money -= self.drawingNum;
self.expenseTotal += self.drawingNum;
lock1.release()
print(f"账户：{self.account.name},余额是：{self.account.money}")
print(f"账户：{self.account.name},总共取了：{self.expenseTotal}")
if __name__ == '__main__':
a1 = Account(100,"zhangsan")
lock1=Lock()
draw1 = Drawing(80,a1) #定义取钱线程对象；
draw2 = Drawing(80,a1) #定义取钱线程对象；
draw1.start() #你取钱
draw2.start() #你老婆取钱
账户：zhangsan,余额是：20
账户：zhangsan,总共取了：80
acquire 和release 方法之间的代码同一时刻只能有一个线程去操作
如果在调用acquire 方法的时候 其他线程已经使用了这个互斥锁，那么此时acquire 方法会堵塞，直到这个互斥锁释放后才能再次上锁。
死锁
在多线程程序中，死锁问题很大一部分是由于一个线程同时获取多个锁造成的。举例：有两个人都要做饭，都需要“锅”和“菜刀”才能炒菜。
from threading import Thread, Lock
from time import sleep
def fun1():
lock1.acquire()
print('fun1拿到菜刀')
sleep(2)
lock2.acquire()
print('fun1拿到锅')
lock2.release()
print('fun1释放锅')
lock1.release()
print('fun1释放菜刀')
def fun2():
lock2.acquire()
print('fun2拿到锅')
lock1.acquire()
print('fun2拿到菜刀')
lock1.release()
print('fun2释放菜刀')
lock2.release()
print('fun2释放锅')
if __name__ == '__main__':
lock1 = Lock()
lock2 = Lock()
t1 = Thread(target=fun1)
t2 = Thread(target=fun2)
t1.start()
t2.start()
fun1拿到菜刀
fun2拿到锅
都未同时拿到菜单和锅，这就没有办法做饭了
解决办法：死锁是由于“同步块需要同时持有多个锁造成”的，要解决这个问题，思路很简单，就是：同一个代码块，不要同时持有两个对象锁。
信号量
互斥锁使用后，一个资源同时只有一个线程访问。如果某个资源，我们同时想让N个(指定数值)线程访问？这时候，可以使用信号量。信号量控制同时访问资源的数量。信号量和锁相似，锁同一时间只允许一个对象(进程)通过，信号量同一时间允许多个对象(进程)通过。
应用场景
1在读写文件的时候，一般只能只有一个线程在写，而读可以有多个线程同时进行，如果需要限制同时读文件的线程个数，这时候就可以用到信号量了（如果用互斥锁，就是限制同一时刻只能有一个线程读取文件）。
2 在做爬虫抓取数据时。
信号量底层就是一个内置的计数器。每当资源获取时(调用acquire)计数器-1,资源释放时(调用release)计数器+1。
#coding=utf-8
from threading import Thread, Lock
from time import sleep
from multiprocessing import Semaphore
"""
一个房间一次只允许两个人通过
若不使用信号量，会造成所有人都进入这个房子
若只允许一人通过可以用锁-Lock()
"""
def home(name, se):
se.acquire() # 拿到一把钥匙
print(f'{name}进入了房间\n')
sleep(3)
print(f'{name}走出来房间\n')
se.release() # 还回一把钥匙
if __name__ == '__main__':
se = Semaphore(2) # 创建信号量的对象，有两把钥匙
for i in range(7):
p = Thread(target=home, args=
(f'tom{i}', se))
p.start()
tom0进入了房间
tom1进入了房间
tom0走出来房间
tom1走出来房间
tom2进入了房间
tom3进入了房间
tom3走出来房间
tom2走出来房间
tom4进入了房间
tom5进入了房间
tom5走出来房间
tom4走出来房间
tom6进入了房间
tom6走出来房间
事件(Event)
事件Event主要用于唤醒正在阻塞等待状态的线程;
Event 对象包含一个可由线程设置的信号标志，它允许线程等待某些事件的发生。在初始情况下，event 对象中的信号标志被设置假。如果有线程等待一个 event 对象，而这个 event 对象的标志为假，那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个 event 对象的信号标志设置为真，它将唤醒所有等待个 event 对象的线程。如果一个线程等待一个已经被设置为真的 event 对象，那么它将忽略这个事件，继续执行
Event() 可以创建一个事件管理标志，该标志（event）默认为False，event对象主要有四种方法可以调用：
| 方法名 | 说明 |
|---|---|
event.wait(timeout=None) | 调用该方法的线程会被阻塞，如果设置了timeout参数，超时后，线程会停止阻塞继续执行； |
event.set() | 将event的标志设置为True，调用wait方法的所有线程将被唤醒 |
event.clear() | 将event的标志设置为False，调用wait方法的所有线程将被阻塞 |
event.is_set() | 判断event的标志是否为True |
#coding:utf-8
#小伙伴们，围着吃火锅，当菜上齐了，请客的主人说：开吃！
#于是小伙伴一起动筷子，这种场景如何实现
import threading
import time
def chihuoguo(name):
#等待事件，进入等待阻塞状态
print(f'{name}已经启动')
print(f'小伙伴{name}已经进入就餐状态！')
time.sleep(1)
event.wait()
# 收到事件后进入运行状态
print(f'{name}收到通知了.' )
print(f'小伙伴{name}开始吃咯！')
if __name__ == '__main__':
event = threading.Event()
# 创建新线程
thread1 = threading.Thread(target=chihuoguo, args=("tom", ))
thread2 = threading.Thread(target=chihuoguo, args=("cherry", ))
# 开启线程
thread1.start()
thread2.start()
time.sleep(10)
# 发送事件通知
print('---->>>主线程通知小伙伴开吃咯！')
event.set()
tom已经启动
小伙伴tom已经进入就餐状态！
cherry已经启动
小伙伴cherry已经进入就餐状态！
---->>>主线程通知小伙伴开吃咯！
tom收到通知了.
小伙伴tom开始吃咯！
cherry收到通知了.
小伙伴cherry开始吃咯！
生产者和消费者模式
多线程环境下，我们经常需要多个线程的并发和协作。这个时候，就需要了解一个重要的多线程并发协作模型“生产者/消费者模式”。
生产者指的是负责生产数据的模块（这里模块可能是：方法、对象、线程、进程）。
消费者指的是负责处理数据的模块（这里模块可能是：方法、对象、线程、进程）
消费者不能直接使用生产者的数据，它们之间有个“缓冲区”。生产者将生产好的数据放入“缓冲区”，消费者从“缓冲区”拿要处理的数据。
缓冲区是实现并发的核心，缓冲区的设置有3个好处：
1 实现线程的并发协作
有了缓冲区以后，生产者线程只需要往缓冲区里面放置数据，而不需要管消费者消费的情况；同样，消费者只需要从缓冲区拿数据处理即可，也不需要管生产者生产的情况。 这样，就从逻辑上实现了“生产者线程”和“消费者线程”的分离。
2 解耦了生产者和消费者
生产者不需要和消费者直接打交道
3 解决忙闲不均，提高效率
生产者生产数据慢时，缓冲区仍有数据，不影响消费者消费；消费者处理数据慢时，生产者仍然可以继续往缓冲区里面放置数据
缓冲区和queue对象
从一个线程向另一个线程发送数据最安全的方式可能就是使用queue 库中的队列了。创建一个被多个线程共享的 Queue 对象，这些线程通过使用 put() 和 get() 操作来向队列中添加或者删除元素。Queue 对象已经包含了必要的锁，所以你可以通过它在多个线程间多安全地共享数据。
【示例】生产者消费者模式典型代码
from queue import Queue
from threading import Thread
from time import sleep
def producer():
num = 1
while True:
if queue.qsize() < 5:
print(f'生产:{num}号，大馒头')
queue.put(f'大馒头：{num}号')
num += 1
else:
print('馒头框满了,等待来人消费啊！')
sleep(1)
def consumer():
while True:
print(f'获取馒头：{queue.get()}')
sleep(1)
if __name__ == '__main__':
queue = Queue()
t = Thread(target=producer)
t.start()
c = Thread(target=consumer)
c.start()
c2 = Thread(target=consumer)
c2.start()
生产:1号，大馒头
生产:2号，大馒头
生产:3号，大馒头
生产:4号，大馒头
生产:5号，大馒头
馒头框满了,等待来人消费啊！
获取馒头：大馒头：1号
获取馒头：大馒头：2号
获取馒头：大馒头：3号获取馒头：大馒头：4号
生产:6号，大馒头
生产:7号，大馒头
生产:8号，大馒头
生产:9号，大馒头
馒头框满了,等待来人消费啊！
…
