Python 并发编程（线程）
目录
- 线程
-
- 多线程的开启
- 线程对象的常用方法
- 守护线程
- 线程之间内存共享
- 互斥锁
- 信号量
- 死锁/递归锁
- 事件Event
- 队列queue
- 定时器
- GIL全局解释器锁
- 线程池
线程
线程：执行单位,cpu执行的就是线程，一个流水线的运行过程（进程内代码的运行过程）
进程：资源单位，会申请一块内存空间来存放程序，进程是包含线程的一个容器
执行一个Python文件默认会开启一个进程，进程内默认包含一个线程（主线程），相当于执行每个操作都是由一个线程来执行的，而我们开启的子进程其中也包含一个线程，所以它占用的资源会远大于创建一个线程。多线程就是在一个进程内开启多个线程。
线程的优势
- 同一进程下的多个线程共享该进程的内存空间。
- 开启子线程的开销远小于开启子进程
线程与进程的区别
1、线程共享创建它的进程的地址空间；进程有自己的地址空间。
2、线程可以直接访问其进程的数据段；进程有自己的父进程数据段副本。
3、线程可以直接与其进程的其他线程通信；进程必须使用进程间通信来与同级进程通信。
4、新线程很容易创建；新进程需要复制父进程。
5、线程可以对同一进程的线程执行相当大的控制；进程只能对子进程执行控制。
6、对主线程的更改（取消、优先级更改等）可能会影响进程的其他线程的行为；对父进程的更改不会影响子进程。
多线程的开启
Python使用threading模块来创建线程，但是其实还有另一种模块_thread也可以创建线程，但基本被淘汰了，其功能远不如threading，所以这里使用的是teahding模块
import threading
import time
def task(n):
print('当前线程：%s 开始了' % threading.currentThread().name)
time.sleep(n)
print('当前线程：%s 结束了' % threading.currentThread().name)
# threading.currentThread() 执行这个函数的线程对象
# .name这个线程的名称
if __name__ == '__main__':
t = threading.Thread(target=task, args=(1,))
t2 = threading.Thread(target=task, args=(2,))
t.start()
t2.start()
t.join()
t2.join()
print('主线程结束了',threading.currentThread().name) # 主线程名称
执行结果
'''
当前线程：Thread-1 开始了
当前线程：Thread-2 开始了
当前线程：Thread-1 结束了
当前线程：Thread-2 结束了
主线程结束了 MainThread
'''
创建使用线程的方式与进程大部分都相似
创建、并开启一个子线程的速度远快于一个子进程
import threading
def task():
print(f'线程：{threading.currentThread().name} 开启')
if __name__ == '__main__':
t = threading.Thread(target=task)
t.start()
print(' 主线程结束了') # 开启线程速度很快，呈现出来的效果几乎会优先这行显示出来
执行结果
'线程：Thread-1 开启 主线程结束了'
以上叙述了一种开启线程的方式，第二种就是通过继承的方式来开启线程
import threading
import time
class MyThread(threading.Thread):
def __init__(self,count):
super().__init__()
self.count = count
def run(self) -> None:
print(f'Thread-{self.count}开启了')
time.sleep(self.count)
print(f'Thread-{self.count}结束了')
if __name__ == '__main__':
t = MyThread(1)
t.start()
t.join() # 主线程等待子线程结束
print('主线程结束了')
线程对象的常用方法
通过提供的方法，我们可以查看当前进程内线程的状态信息
import threading
threading.currentThread() # 获取当前线程对象
# threading.current_thread() 效果一样
print(threading.currentThread().name) # 获取线程的名称
print(threading.currentThread().is_alive()) # 获取这个线程是否存活
print(threading.active_count()) # 当前进程活跃线程的数量
print(threading.enumerate()) # 当前进程内所有活跃的线程，返回一个列表
print(threading.get_ident()) # 获取当前线程编号
守护线程
当某个线程成为守护线程，它首要关注的是主线程的生命周期，如果主线程生命周期结束，不管这个守护线程是否正在运行，都会随之结束。
守护线程与守护进程不同的是：
守护进程关注的是：父进程的代码是否执行完毕。
守护线程关注的是：当前程序的任务是否执行完毕，但不包括守护线程。
import threading
import time
# 守护线程：守护的是主线程的生命周期
def task(n):
print(f' 子线程：{threading.current_thread().name} 开启了') # 获取线程名称
time.sleep(n)
print(f' 子线程：{threading.current_thread().name} 结束了')
if __name__ == '__main__':
t = threading.Thread(target=task,args=(10,))
t.daemon = True # 将t变成守护线程
t2 = threading.Thread(target=task,args=(5,))
t.start()
t2.start()
# 当前程序，当这个线程运行完以后，整体主线程就会结束，那么不管t线程是否运行完毕，都会结束
# 主线程会等待所有子线程结束，生命周期才会结束，但是不包括守护线程。
# 也就是说主线程会等待其它的线程，而不会等待守护线程，当其它线程结束以后，主线程就会结束，并且会携带守护线程一起离去
执行结果
'''
子线程：Thread-1 开启了
子线程：Thread-2 开启了
子线程：Thread-2 结束了
'''
但也有情况就是，主线程等待其它线程运行过程中，守护线程运行完毕了
注意：不要给守护线程添加join方法，因为这样就会失去守护线程应有的效果
import threading
import time
# 守护线程：守护的是主线程的生命周期
def task(n):
print(f' 子线程：{threading.current_thread().name} 开启了') # 获取线程名称
time.sleep(n)
print(f' 子线程：{threading.current_thread().name} 结束了')
if __name__ == '__main__':
t = threading.Thread(target=task,args=(10,))
t.daemon = True # 将t变成守护线程
t2 = threading.Thread(target=task,args=(5,))
t.start()
t2.start()
t.join()
给守护线程添加join后，主线程也会等待这个守护线程执行完毕，此时它就成了一个普通的线程
'''
子线程：Thread-1 开启了
子线程：Thread-2 开启了
子线程：Thread-2 结束了
子线程：Thread-1 结束了
'''
线程之间内存共享
相同进程下的线程之间的数据是共享的，如果相同进程下的多线程需要通信，可以在主线程定义一个共享变量、或队列来实现信息互通，而不同进程下的线程如果需要通信，则只能通过队列、管道等等
import threading
import time
count = 100
def task():
global count
print(f'子线程：{threading.currentThread().name}',count)
count += 1 # 修改主线程内的count变量值
if __name__ == '__main__':
start = time.time()
t = threading.Thread(target=task)
t.start()
t.join()
print(f'主线程：{threading.currentThread().name}',count)
执行结果
'''
子线程：Thread-1 100
主线程：MainThread 101
'''
如果使用过进程执行该操作就会知道，子进程是将父进程内的名称空间完整拷贝一份，进行的操作不会影响到父进程。而线程则是直接可以访问主线程数据及修改操作，不需要拷贝。
互斥锁
在多个线程修改某个共享数据时，如果要确保数据的安全性，那么就需要进行线程同步了。线程同步可以保证多个线程安全访问数据，这样也会避免同一时间操作相同数据造成的错乱，引入互斥锁是很好的选择。
未加锁前，修改同一数据，不妨猜测一下执行结果
import threading
import time
count = 0
lock = threading.Lock()
def task():
global count
for i in range(100000):
count += 1
if __name__ == '__main__':
thread = []
start = time.time()
for i in range(10):
t = threading.Thread(target=task)
t.start()
thread.append(t)
for i in thread:
i.join()
print(time.time() - start)
print(f'主线程：{threading.currentThread().name}',count)
执行结果
'''
0.10023021697998047
主线程：MainThread 871675
'''
造成这种结果的原因是：本质上每个线程会给这个count增加10000，有可能在某一次多个线程同时进行了+=1的操作，时间完全相同，那么此时这个count只会+1，从而导致多次这样，导致数据已经错乱。
ps：但是也有可能数值是准确的，那么我们可以再把for循环次数调高一些
而如果我们要以这种方式将count变为理想数字的话，需要使用互斥锁来对每个线程的操作进行锁定，待执行完以后再进行释放。
import threading
import time
count = 0
lock = threading.Lock()
def task():
global count
lock.acquire()
for i in range(100000):
count += 1
lock.release()
if __name__ == '__main__':
thread = []
start = time.time()
for i in range(10):
t = threading.Thread(target=task)
t.start()
thread.append(t)
for i in thread:
i.join()
print(time.time() - start)
print(f'主线程：{threading.currentThread().name}',count)
执行结果
'''
0.09698486328125
主线程：MainThread 1000000
'''
当每次线程执行完操作以后，下一个线程才能执行，这就变成的串行执行，但是数据达到了保证，不会出现错乱。
信号量
可以理解为锁，但是信号量可以指定锁的数量，可以根据信号量值来进行锁定。
from threading import Thread,Semaphore,currentThread
import time
import random
def func():
sm.acquire()
print(f'{currentThread().name} 正在运行')
time.sleep(random.randint(1,3))
print(f'{currentThread().name} 运行完毕')
sm.release()
# 当5信号量被5个线程使用后，其它线程只能等待其中某个释放，才能执行
if __name__ == '__main__':
sm = Semaphore(5) # 指定信号量值
for i in range(15):
t = Thread(target=func)
t.start()
信号量与互斥锁的区别：
1、互斥量用于线程的互斥，信号量用于线程的同步。这是互斥量和信号量的根本区别，也就是互斥和同步之间的区别。
/
互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的。
/
同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源。
死锁/递归锁
造成死锁的原因是：线程获取锁时无法获取到，那么程序就会一直阻塞在原地，且不会报错，给我们造成的错觉就是程序还在运行中。
代码演示死锁情况：
from threading import Thread,Lock,RLock,currentThread
import time
# 创建两个锁
lockA = Lock()
lockB = Lock()
class MyThread(Thread):
def run(self) -> None:
self.f1()
self.f2()
def f1(self):
lockA.acquire()
print(f'{self.name} 抢到A锁')
lockB.acquire()
print(f'{self.name} 抢到B锁')
lockB.release()
lockA.release()
def f2(self):
lockB.acquire()
print(f'{self.name} 抢到B锁')
time.sleep(0.1)
lockA.acquire()
print(f'{self.name} 抢到A锁')
lockA.release()
lockB.release()
if __name__ == '__main__':
for i in range(4): # 启动4个线程
t = MyThread()
t.start()
执行结果
'''
Thread-1 抢到A锁
Thread-1 抢到B锁
Thread-1 抢到B锁
Thread-2 抢到A锁
'''
分析：
当线程1执行f1函数时，由于它启动速度够快首先就拿到了A锁，那么此时其它线程开启后只能等待它把A锁释放掉，当线程1执行到f2后，已经将A锁释放了，所有线程就可以竞争拿到A锁，然后线程1执行f2函数拿到B锁，线程1手里拿到B锁进入睡眠0.1s的过程中，线程2已经把A锁抢到了，而此时线程2又想获取B锁，当线程1睡眠结束想获取A锁时，却发现A锁正在被使用，所以它们都在等对方释放锁，所以就会出现死锁现象。
如果出现这种锁套锁的写法，我们为了避免出现死锁，通常使用递归锁来解决问题
递归锁可以进行多次acquire()，每次锁定都会计数+1，每次释放都会计数-1，当其它线程想要获取锁时，首先会检测计数是否为0，如果为0则可以获取。
from threading import Thread,RLock
import time
lockA = lockB = RLock() # 链式赋值，lockA和lockB是同一个锁
class MyThread(Thread):
def run(self) -> None:
self.f1()
self.f2()
def f1(self):
lockA.acquire()
print(f'{self.name} 抢到A锁')
lockB.acquire()
print(f'{self.name} 抢到B锁')
lockB.release()
lockA.release()
def f2(self):
lockB.acquire()
print(f'{self.name} 抢到B锁')
time.sleep(0.1)
lockA.acquire()
print(f'{self.name} 抢到A锁')
lockA.release()
lockB.release()
if __name__ == '__main__':
for i in range(4):
t = MyThread()
t.start()
执行结果
'''
Thread-1 抢到A锁
Thread-1 抢到B锁
Thread-1 抢到B锁
Thread-1 抢到A锁
Thread-3 抢到A锁
Thread-3 抢到B锁
Thread-3 抢到B锁
Thread-3 抢到A锁
Thread-4 抢到A锁
Thread-4 抢到B锁
Thread-4 抢到B锁
Thread-4 抢到A锁
Thread-2 抢到A锁
Thread-2 抢到B锁
Thread-2 抢到B锁
Thread-2 抢到A锁
'''
注意：lockA和lockB是同一个锁，当lockB被某个线程拿到后，锁的计数就会加1，所以其它线程都不能拿到锁。
分析：
当线程1开启后执行了f1函数，此时其它线程都在等待线程1执行完该函数把锁释放掉，但是线程1执行完f1函数后，很快啊，又执行到了f2函数，又拿到了锁，所以呈现给我们的就是这么整齐的效果。（ps：也有可能是笔者电脑的原因，有可能的效果就是线程1执行完f1函数后，准备执行f2函数，同时其它线程执行了f1函数，拿到了锁，然后开始操作。）
事件Event
通过threading.Event()可以创建一个事件管理标志，该标志Event()默认为False。
它具备4个常用方法：
event.wait(timeout=None)：调用该方法的线程会被阻塞，如果设置了timeout参数，超时后，线程会停止阻塞继续执行
event.set()：将event的标志设置为True，调用wait方法的所有线程将被唤醒
event.clear()：将event的标志设置为False，调用wait方法的所有线程将被阻塞
event.isSet()：判断event的标志是否为True，ps：event.is_set()效果相同
代码示例：
from threading import Thread,Event,currentThread
import time
e = Event() # 创建一个事件标识，默认为False
def f1():
print(f'{currentThread().name} 正在运行')
time.sleep(3)
print(f'{currentThread().name} 运行结束')
e.set() # 将e事件设置为True
def f2():
e.wait() # 如果e事件不为True则进入阻塞
print(f'{currentThread().name} 正在运行')
e.clear() # 将这个事件变成False
if __name__ == '__main__':
t = Thread(target=f1)
t2 = Thread(target=f2)
t.start()
t2.start()
执行结果
'''
Thread-1 正在运行
Thread-1 运行结束
Thread-2 正在运行
'''
这里相当于两个线程都用于这个事件，第二个线程必须阻塞等待这个事件变为True，所以需要等待第一个线程再执行完，将这个事件变为True，第二个线程才可以运行，第二个线程运行完毕就可以再次将这个事件还原为False
模拟红绿灯（不包括黄灯）
from threading import Thread,Event
import time
from faker import Faker # 创建伪数据
import random
e = Event()
def traffic_lights():
while True:
e.clear()
print('红灯亮')
time.sleep(2)
e.set()
print('绿灯亮')
time.sleep(3)
def pedestrian():
faker = Faker(locale='en_AU') # 创建Australia地区的假数据
name = faker.name() # 获取这个地区的名称数据
while True:
if e.is_set():
print(f'{name} 走过去了')
break
else:
print(f'{name} 等待绿灯')
e.wait()
if __name__ == '__main__':
Thread(target=traffic_lights).start() # 先将红绿灯开启
while True: # 不断创建行人
time.sleep(random.randint(1,3)) # 1-3s 来一个行人
Thread(target=pedestrian).start()
执行结果
'''
红灯亮
绿灯亮
Cheryl Butler 走过去了
Ralph Perry 走过去了
红灯亮
Mr. David Austin PhD 等待绿灯
绿灯亮
Mr. David Austin PhD 走过去了
Kim Reed 走过去了
........
'''
pedestrian函数会根据traffic_lights函数改变Event标志来行动
队列queue
queue模块实现了生产者、消费者队列（详见可以去了解笔者的进程篇）当信息必须安全的在多线程之间交换时，该模块可以很好的作为中间的桥梁。
该模块主要实现了三种类型的队列：
FIFO：先进先出（队列）
LIFO：后进先出（堆栈）
Priority：优先级队列
1、FIFO队列
import queue
# 队列：先进先出
q = queue.Queue() # 括号内加入数字，表示指定可入队数量，不添加则无上限
# 入队
q.put(1)
q.put(2)
q.put(3)
# 出队
print(q.get()) # 1
print(q.get()) # 2
print(q.get()) # 2
print(q.get()) # 当队列为空时，get就会进入阻塞状态。
print(q.get(block=False)) # block=False表示队列满了，则直接报错
q.get(timeout=3) # timeout=3表示：3s内如果没有get到数据，则报错
2、LIFO堆栈
q = queue.LifoQueue()
q.put(1)
q.put(2)
q.put(3)
print(q.get()) # 3
print(q.get()) # 2
print(q.get()) # 1
3、优先级队列
# 优先级队列，入队时需要设置数字代表优先级，数字越低，优先级越高，以元组形式入队
q = queue.PriorityQueue()
# 第一个参数必须是数字，代表优先级
q.put((10,'元素1'))
q.put((20,'元素2'))
q.put((-10,'元素3'))
q.put((-15,'元素4'))
# 按优先级从高到低出队
print(q.get()) # (-15, '元素4')
print(q.get()) # (-10, '元素3')
print(q.get()) # (10, '元素1')
print(q.get()) # (20, '元素2')
常用方法（三种类型通用）：
q = queue.Queue(3)
print(q.empty()) # 当队列为空，返回True，不为空则返回False
# True
print(q.full()) # 队列满了，返回True，否则返回False
# False
q.put() # 入队
q.get() # 出队
q.task_done() # 通常在q.get()后使用，它主要向队列发送信号，已取出一个数据
q.join() # 阻塞当前线程。如果q.task_done发出信号的次数，与put入队的次数相同，则取消阻塞
print(q.maxsize) # 可入队个数，如果未指定，则为0
# 3
定时器
Timer（定时器）是Thread的派生类，用于在指定时间后调用一个方法。
语法
from threading import Timer
Timer(interval, function, args=None, kwargs=None):
interval：指定时间
function：需要执行的方法
args | kwargs：向指定方法传递的参数
实例
def index():
print(f'My name is ')
timer = Timer(3,index) # 无参数传递
timer.start()
def index(name):
print(f'My name is {name}')
timer = Timer(3,index,('jack',)) # 位置传参
timer.start()
def index(name):
print(f'My name is {name}')
timer = Timer(3,index,{
'name':'jack'}) # 关键字传参
timer.start()
本质上就是：达到指定时间后，开启一条线程来执行。
GIL全局解释器锁
https://blog.csdn.net/m0_46958731/article/details/113002518
线程池
看过笔者进程篇里面的进程池，再来使用这个线程池，就会发现使用方式几乎完全相同
我们可以指定线程并发的数量，异步调用
from concurrent.futures import ThreadPoolExecutor
from threading import currentThread
import time
def task(i):
print(f'{currentThread().name} 正在运行{i}')
time.sleep(2)
print(f'{currentThread().name} 运行结束{i}\n')
return i
def handle(future):
future = future.result() # 拿到线程对象执行任务的结果
print(f'{currentThread().name} 处理结果{future}')
if __name__ == '__main__':
t = ThreadPoolExecutor(10)
for i in range(20):
t.submit(task,i).add_done_callback(handle)
# 将执行任务的线程对象，回调给handle函数
执行结果
'''
ThreadPoolExecutor-0_0 正在运行0ThreadPoolExecutor-0_1 正在运行1
ThreadPoolExecutor-0_2 正在运行2
ThreadPoolExecutor-0_3 正在运行3
ThreadPoolExecutor-0_4 正在运行4
ThreadPoolExecutor-0_5 正在运行5
ThreadPoolExecutor-0_6 正在运行6
ThreadPoolExecutor-0_7 正在运行7
ThreadPoolExecutor-0_8 正在运行8
ThreadPoolExecutor-0_9 正在运行9
ThreadPoolExecutor-0_1 运行结束1
ThreadPoolExecutor-0_4 运行结束4
ThreadPoolExecutor-0_4 处理结果4
ThreadPoolExecutor-0_2 运行结束2
ThreadPoolExecutor-0_0 运行结束0
ThreadPoolExecutor-0_7 运行结束7
ThreadPoolExecutor-0_7 处理结果7
ThreadPoolExecutor-0_0 处理结果0
ThreadPoolExecutor-0_5 运行结束5
ThreadPoolExecutor-0_5 处理结果5
ThreadPoolExecutor-0_8 运行结束8
ThreadPoolExecutor-0_8 处理结果8
ThreadPoolExecutor-0_2 处理结果2
ThreadPoolExecutor-0_6 运行结束6
ThreadPoolExecutor-0_6 处理结果6
ThreadPoolExecutor-0_3 运行结束3
ThreadPoolExecutor-0_3 处理结果3
ThreadPoolExecutor-0_1 处理结果1
ThreadPoolExecutor-0_9 运行结束9
ThreadPoolExecutor-0_9 处理结果9
'''
map方法：取代了我们for循环submit的用法
from concurrent.futures import ThreadPoolExecutor
from threading import currentThread
import time
def task(i):
print(f'{currentThread().name} 正在运行{i}')
time.sleep(2)
print(f'{currentThread().name} 运行结束{i}\n')
return i
if __name__ == '__main__':
t = ThreadPoolExecutor(10)
lis = [
'Hello',
'World',
'Nihao',
'Python'
]
t.map(task,lis) # (函数，传递的参数)
t.shutdown(wait=True)
执行结果
'''
ThreadPoolExecutor-0_0 正在运行Hello
ThreadPoolExecutor-0_1 正在运行World
ThreadPoolExecutor-0_2 正在运行Nihao
ThreadPoolExecutor-0_3 正在运行Python
ThreadPoolExecutor-0_0 运行结束Hello
ThreadPoolExecutor-0_3 运行结束Python
ThreadPoolExecutor-0_1 运行结束World
ThreadPoolExecutor-0_2 运行结束Nihao
'''
技术小白记录学习过程，有错误或不解的地方请指出，如果这篇文章对你有所帮助请
点赞 收藏+关注子夜期待您的关注，谢谢支持！