第三十八天 GIL 进程池与线程池

时间:2022-09-07 08:50:20

一.全局解释器锁

  1.GIL:全局解释器锁

    GIL本质就是一把互斥锁,是夹在解释器身上的

    统一进程内的所有线程都需要先抢到GIL锁,才能执行pai解释器代码

  2.GIL优缺点:

    优点:

      保证Cpython解释器内存管理的线程安全

    缺点:

      同一进程内所有的线程同一时刻只能有一个执行,

      也就是锁Cpython解释器多线程无法实现真正的并行

from threading import Thread,current_thread
import time def task():
print("%s is running"%current_thread().name)
time.sleep(3)
print("%s is done"current_thread().name) if __name__=="__main__":
t1=Thread(target=task)
t2=Thread(target=task)
t3=Thread(target=task)
t1.start()
t2.start()
t3.start()

二.Cpython解释器并发效率验证

关于GIL性能的讨论

解释器加锁以后
将导致所有线程只能并发 不能达到真正的并行 意味着同一时间只有一个CPU在处理你的线程
给你的感觉是效率低

代码执行有两种状态
阻塞 i/o 失去CPU的执行权 (CPU等待IO完成)
非阻塞 代码正常执行 比如循环一千万次 中途CPU可能切换 很快会回来 (CPU在计算)

假如有32核CPU 要处理一个下载任务 网络速度慢 100k/s 文件大小为1024kb
如果你的代码中IO操作非常多 cpu性能不能直接决定你的任务处理速度

案例:
目前有三个任务 每个任务处理需一秒 获取元数据需要一小时
3个CPU 需要 一小时1秒
1个cpu 需要 一小时3秒

在IO密集的程序中 CPU性能无法直接决定程序的执行速度 python就应该干这种活儿
在计算密集的程序中 CPU性能可以直接决定程序的执行速度

#计算密集型测试
from threading import Thread
from multiprocessing import Process
import time # 计算密集任务 def task1():
sum = 1
for i in range(10000000):
sum *= i def task2():
sum = 1
for i in range(10000000):
sum *= i def task3():
sum = 1
for i in range(10000000):
sum *= i def task4():
sum = 1
for i in range(10000000):
sum *= i def task5():
sum = 1
for i in range(10000000):
sum *= i def task6():
sum = 1
for i in range(10000000):
sum *= i if __name__ == '__main__': # 开始时间
st_time = time.time()
# 多线程情况下
# t1 = Thread(target=task1)
# t2 = Thread(target=task2)
# t3 = Thread(target=task3)
# t4 = Thread(target=task4)
# t5 = Thread(target=task5)
# t6 = Thread(target=task6) t1 = Process(target=task1)
t2 = Process(target=task2)
t3 = Process(target=task3)
t4 = Process(target=task4)
t5 = Process(target=task5)
t6 = Process(target=task6) t1.start()
t2.start()
t3.start()
t4.start()
t5.start()
t6.start()
#
# t1.join()
# t2.join()
# t3.join()
# t4.join()
# t5.join()
# t6.join() print(time.time() - st_time)
from threading import Thread
from multiprocessing import Process
import time # 计算密集任务
def task1():
time.sleep(3) def task2():
time.sleep(3) def task3():
time.sleep(3) def task4():
time.sleep(3) def task5():
time.sleep(3) def task6():
time.sleep(3) if __name__ == '__main__': # 开始时间
st_time = time.time()
# 多线程情况下
# t1 = Thread(target=task1)
# t2 = Thread(target=task2)
# t3 = Thread(target=task3)
# t4 = Thread(target=task4)
# t5 = Thread(target=task5)
# t6 = Thread(target=task6) t1 = Process(target=task1)
t2 = Process(target=task2)
t3 = Process(target=task3)
t4 = Process(target=task4)
t5 = Process(target=task5)
t6 = Process(target=task6) t1.start()
t2.start()
t3.start()
t4.start()
t5.start()
t6.start() # t1.join()
# t2.join()
# t3.join()
# t4.join()
# t5.join()
# t6.join() print(time.time() - st_time)

三.GIL与互斥锁

from  threading import Thread,Lock
import time mutex = Lock()
num = 1
def task():
global num
# print(num)
mutex.acquire()
temp = num
print(temp)
time.sleep(1) # 当你们线程中出现io时 GIL锁就解开
num = temp + 1
mutex.release() # 线程任务结束时GIL锁解开 t1 = Thread(target=task,) t2 = Thread(target=task,)
t1.start()
t2.start()
t1.join()
t2.join()
print(num)

GIL 和自定义互斥锁的区别

全局锁不能保证自己开启的线程安全 但要保证解释器中的数据的安全

GIL 在线程调用解释器是 自动加锁 在IO阻塞时或线程执行完毕时 自动解锁

四.进程池和线程池

  进程池

    就是一个装进程的容器

  为什么出现

    当进程很多的时候方便管理进程

  什么时候用?

    当并发量特别大的时候 列入双十一

    很多时候进程是空闲的 就让他进入进程池 让有任务处理时才从进程取出来使用

  进程池使用

    ProcessPoolExecutor类

    创建时指定最大进程数 自动创建进程

    调用submit函数将任务提交进程池中

    创建进程是在调用submit后发生

  总结一下:

    进程池可以自动创造进程

    进程现在最大进程数

    自动选择一个空闲的进程帮你处理任务

  进程什么时候算是空闲?

    代码执行完算是空闲

  IO密集时 用线程池

  计算密集时 用线程池

思考

1、什么是GIL

GIL = Global Interpreter Lock (全局解释锁器锁)
2、有了GIL会对单进程下的多个线程造成什么样的影响

防止对个线程竞争统一资源造成数据的错乱,只能有一个线程进行读写操作.
3、为什么要有GIL

为了避免资源竞争造成的数据错乱
4、GIL与自定义互斥锁的区别,多个线程争抢GIL与自定义互斥锁的过程分析

GIL不保证自己开启线程的安全 但保证解释器中数据的安全

GIL 在线程调用解释其时 自动加锁 在IO阻塞是或线程代码执行完毕时,自动解锁
5、什么时候用python的多线程,什么时候用多进程,为什么?

2、进程池与线程池
1、池的用途,为何要用它

池用来存储线程和进程,可以方便进程和线程的管理
2、池子里什么时候装进程什么时候装线程?

计算密集时装进程,IO密集时装线程

3、基于进程池与线程池实现并发的套接字通信

#服务端

from socket import *
from threading import Thread
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor tpool=ThreadPoolExecutor(3) def communicte(conn,client_addr):
while True:
try:
data= conn.recv(1024)
if not data:break
conn.send(data.upper())
except ConnectionAbortedError:
break
conn.close() def server():
server = socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8080))
server.listen(5) while True:
conn,client_addr=server.accept()
print(client_addr)
tpool.submit(communicte,conn,client_addr)
server.close() if __name__=='__main__':
server()
#客户端
import socket c = socket.socket()
c.connect(('127.0.0.1',8080))
while True:
msg = input(">>>:")
c.send(msg.encode("utf-8"))
data = c.recv(1024)
print(data.decode("utf-8"))