并发编程(三) GIL全局解释器锁和其他知识
GIL全局解释器锁
全局解释器的官方解释
In CPython, the global interpreter lock, or GIL, is a mutex that prevents multiple
native threads from executing Python bytecodes at once. This lock is necessary mainly
because CPython’s memory management is not thread-safe.
ps:python解释器有很多种 最常见的就是Cpython解释器
GIL的存在是因为CPython解释器的内存管理不是线程安全的
垃圾回收机制
1.引用计数
2.标记清除
3.分代回收
引用计数：值和变量绑定关系的个数
标记清除：内存快满的时候，扫描内存，没有绑定变量的值会被清除掉
分代回收：频繁扫描是无意义的，因此采取措施降低扫描频率。垃圾回收是会消耗资源的，而程序运行内部会用到变量与值，并且部分是于常量，要减少垃圾回收消耗的时间
GIL本质也是一把互斥锁:将并发变成串行牺牲效率保证数据的安全
用来阻止同一个进程下的多个线程的同时执行(同一个进程内多个线程无法实现并行但是可以实现并发)
python的多线程没法利用多核优势 是不是就是没有用了?
研究python的多线程是否有用需要分情况讨论
四个任务 计算密集型的
分析：计算密集，无阻塞态，一个线程走完另一个线程启动，因此开4个线程需要40秒
开4个进程，那就是并行，因此只需要10秒
单核情况下
开线程更省资源
多核情况下
开进程 10s
开线程 40s
计算密集型,多核开进程最快
from multiprocessing import Process
from threading import Thread
import os, time
def work():
res = 0
for i in range(10000000):
res *= i
if __name__ == '__main__':
l = []
# print(os.cpu_count()) # 本机为6核
start = time.time()
for i in range(6):
p=Process(target=work) # 耗时 2.8391623497009277
# p = Thread(target=work) # 耗时 4.586262226104736
l.append(p)
p.start()
for p in l:
p.join()
stop = time.time()
print('run time is %s' % (stop - start))
四个任务 IO密集型的
分析：阻塞态，开哪个都可以，都是等待，开进程开销还更大，因此开线程
单核情况下
开线程更节省资源
多核情况下
开线程更节省资源
# IO密集型开线程更节省资源
from multiprocessing import Process
from threading import Thread
import threading
import os,time
def work():
time.sleep(2)
if __name__ == '__main__':
l=[]
print(os.cpu_count()) #本机为6核
start=time.time()
for i in range(4000):
p=Process(target=work) #耗时9.001083612442017s多,大部分时间耗费在创建进程上
# p=Thread(target=work) #耗时2.051966667175293s多
l.append(p)
p.start()
for p in l:
p.join()#join的作用：让列表中的线程不要接着往下走！
stop=time.time()
print('run time is %s' %(stop-start))
join的作用：让进程等待结束再进行下一个进程（后来总结：让列表中的线程不要接着往下走！）
如何实现TCP服务端实现并发？
思路：while循环开线程
#服务端
server = socket.socket()
server.bind(('127.0.0.1',8080))
server.listen(5)
def talk(conn):
while True:
try:
data = conn.recv(1024)
if len(data) == 0:break
print(data.decode('utf-8'))
conn.send(data.upper())
except ConnectionResetError as e:
print(e)
break
conn.close()
while True:
conn, addr = server.accept() # 监听 等待客户端的连接 阻塞态
t = Thread(target=talk,args=(conn,))
t.start()
ps:常见问题
GIL是不是python解释器的特点？
GIL是Cpython解释器的特点，python解释器有多个语言编写的版本
GIL与普通互斥锁
from threading import Thread
import time
n = 100
def task():
global n
tmp = n
# time.sleep(1)
n = tmp -1
t_list = []
for i in range(100):
t = Thread(target=task)
t.start()
t_list.append(t)
for t in t_list:
t.join()#
print(n)
之前不明白第二个for循环join什么时候开始运行，在线程sleep的时候，原本是直接到最下面执行print，现在多了两行代码，走到join这里，发现要等待，不能跳着运行
死锁
死锁的原因是一个线程抢两把锁
from threading import Thread,Lock,current_thread,RLock
import time
mutexA = Lock()
mutexB = Lock()
class MyThread(Thread):
def run(self): # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发
self.func1()
self.func2()
def func1(self):
#抢锁外，隔离
mutexA.acquire()
print('%s抢到了A锁'%self.name) # self.name等价于current_thread().name
mutexB.acquire()
print('%s抢到了B锁'%self.name)
mutexB.release()
print('%s释放了B锁'%self.name)
mutexA.release()
print('%s释放了A锁'%self.name)
def func2(self):
mutexB.acquire()
print('%s抢到了B锁'%self.name)
# time.sleep(1)
mutexA.acquire()
print('%s抢到了A锁' % self.name)
mutexA.release()
print('%s释放了A锁' % self.name)
mutexB.release()
print('%s释放了B锁' % self.name)
for i in range(10):
t = MyThread()
t.start()
现在是线程1跑到func2，抢到了B锁，准备抢A锁，而A锁在线程2的手上产生了死锁
创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发
self.name等价于current_thread().name。线程号的意思
不要轻易动“锁”有关的事！
解决方法：Rlock递归锁
所有取名递归，就是它可以有一个计数的功能，数值可加可减
将锁替换为Rlock()即可
from threading import Thread,Lock,current_thread,RLock
import time
from threading import Thread,Lock,current_thread,RLock
import time
"""
Rlock可以被第一个抢到锁的人连续的acquire和release
每acquire一次锁身上的计数加1
每release一次锁身上的计数减1
只要锁的计数不为0 其他人都不能抢
"""
# mutexA = Lock()
# mutexB = Lock()
mutexA = mutexB = RLock() # A B现在是同一把锁
class MyThread(Thread):
def run(self): # 创建线程自动触发run方法 run方法内调用func1 func2相当于也是自动触发
self.func1()
self.func2()
def func1(self):
mutexA.acquire()
print('%s抢到了A锁'%self.name) # self.name等价于current_thread().name
mutexB.acquire()
print('%s抢到了B锁'%self.name)
mutexB.release()
print('%s释放了B锁'%self.name)
mutexA.release()
print('%s释放了A锁'%self.name)
def func2(self):
mutexB.acquire()
print('%s抢到了B锁'%self.name)
time.sleep(1)
mutexA.acquire()
print('%s抢到了A锁' % self.name)
mutexA.release()
print('%s释放了A锁' % self.name)
mutexB.release()
print('%s释放了B锁' % self.name)
for i in range(10):
t = MyThread()
t.start()
信号量
与互斥锁类似
互斥锁，就是多个线程抢一个坑位
信号量，就是多个线程抢多个坑位
互斥锁:一个厕所(一个坑位)
信号量:公共厕所(多个坑)
导入模块from threading import Semaphore,Thread
from threading import Semaphore,Thread
import time
import random
sm = Semaphore(5) # 造了一个含有五个的坑位的公共厕所
#以下位置进行加锁
def task(name):
sm.acquire()#加锁位置
print('%s占了一个坑位'%name)
time.sleep(random.randint(1,3))
sm.release()#放锁位置
print('%s走了'%name)
for i in range(40):
t = Thread(target = task ,args =(i,))
t.start()
结果：
0占了一个坑位
1占了一个坑位
2占了一个坑位
3占了一个坑位
4占了一个坑位
4走了
0走了
1走了
3走了
2走了
event事件
之前的join方法是让主进程等待子进程
案例演示：等红绿灯
操作步骤：
1先生成一个event对象
2发信号e.set()
3.等待信号e.wait()
from threading import Event,Thread
import time
# 先生成一个event对象
e = Event()
def light():
print('红灯正亮着')
time.sleep(1)
e.set() # 发信号
print('绿灯亮了')
def car(name):
print('%s正在等红灯'%name)
e.wait() # 等待信号
print('%s加油门飙车了'%name)
t = Thread(target=light)
t.start()
for i in range(10):
t = Thread(target=car,args=('伞兵%s'%i,))
t.start()
线程q
同一个进程下的多个线程本来就是数据共享 为什么还要用队列
因为队列是管道+锁 使用队列你就不需要自己手动操作锁的问题
因为锁操作的不好极容易产生死锁现象
q = queue.Queue()
q.put('hahha')
print(q.get())
q = queue.LifoQueue()
q.put(1)
q.put(2)
q.put(3)
print(q.get())
q = queue.PriorityQueue()
# 数字越小 优先级越高
q.put((10,'haha'))
q.put((100,'hehehe'))
q.put((0,'xxxx'))
q.put((-10,'yyyy'))
print(q.get())