标签：mutex 请求 image width second 优先级 UNC 模块 多核
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
标签：mutex 请求 image width second 优先级 UNC 模块 多核
原文地址：https://www.cnblogs.com/renvip/p/11352646.html
