GIL全局解释器锁
Cpython解释器：python解释器有很多种，最常见的就是Cpython解释器
GIL本质也是一把互斥锁
将并发变成串行牺牲效率保证数据的安全
用来阻止同一个进程下的多个线程的同时执行
(同一个进程内多个线程无法实现并行但是可以实现并发)
GIL的存在是因为CPython解释器的内存管理不是线程安全的
因为进程内的垃圾回收机制也是一个线程，所以有可能造成其他线程例如赋值时，刚创建值，还没指向变量名就被回收，再赋值直接报错
python的多线程没法利用多核优势 是不是就是没有用了?
研究python的多线程是否有用需要分情况讨论
四个任务 计算密集型的 10s
单核情况下
开线程更省资源
多核情况下
开进程 10s
开线程 40s
四个任务 IO密集型的
单核情况下
开线程更节省资源
多核情况下
开线程更节省资源
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)
死锁与递归锁
所谓死锁： 是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程，如下就是死锁
from threading import Lock as Lock import time mutexA=Lock() mutexA.acquire() mutexA.acquire() print(123) mutexA.release() mutexA.release()
解决方法：递归锁
在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock
这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：
"""
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()
信号量
信号量可能在不同的领域中 对应不同的知识点
信号量通过threading模块的Senmaphore类创建一个含有多个锁孔的锁对象，抛出这个锁喉，可被多个线程抢到，每抢到一个就少一个位置，直到有钥匙释放后有多出的空位了，可再被其他线程抢。
"""
互斥锁:一个厕所(一个坑位)
信号量:公共厕所(多个坑位)
"""
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()
for i in range(40):
t = Thread(target=task,args=(i,))
t.start()
Event事件
通过threading模块的Event类创建一个事件对象，set用来发信号，wait用来等待信号，如果没有信号发出，含有wait的线程都会等在那里
案例：红绿灯
from threading import Event,Thread
import time
# 先生成一个event对象
e = Event()
def light():
print('红灯正亮着')
time.sleep(3)
e.set() # 发信号
print('绿灯亮了')
def car(name):
print('%s正在等红灯'%name)
e.wait() # 等待信号
print('%s加油门飙车了'%name)
def blackcar(name):
print('%s不用等红灯'%name)
print('%s加油门飙车了'%name)
t = Thread(target=light)
t.start()
t1 = Thread(target=blackcar,args=('黑车',))
t1.start()
for i in range(5):
t = Thread(target=car,args=('赛车%s'%i,))
t.start()
线程队列
queue队列 ：使用import queue，用法与进程Queue一样
同一个进程下的多个线程本来就是数据共享 为什么还要用队列
因为队列是管道+锁 使用队列你就不需要自己手动操作锁的问题
因为锁操作的不好极容易产生死锁现象
class queue.Queue(maxsize=0) # 先进先出
import queue
q=queue.Queue()
q.put('first')
q.put('second')
q.put('third')
print(q.get())
print(q.get())
print(q.get())
'''
结果(先进先出):
first
second
third
'''
class queue.LifoQueue(maxsize=0) # last in fisrt out 后进先出
import queue
q=queue.LifoQueue()
q.put('first')
q.put('second')
q.put('third')
print(q.get())
print(q.get())
print(q.get())
'''
结果(后进先出):
third
second
first
'''
class queue.PriorityQueue(maxsize=0) # 存储数据时可设置优先级的队列
import queue q=queue.PriorityQueue() # put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高 q.put((20,'a')) q.put((10,'b')) q.put((30,'c')) print(q.get()) print(q.get()) print(q.get()) ''' 结果(数字越小优先级越高,优先级高的优先出队): (10, 'b') (20, 'a') (30, 'c') '''
END
来源：https://www.cnblogs.com/renvip/p/11352646.html