首页 教程Python正文

【并发编程】锁/线程队列/信号量/Event事件

從出茳湖 Python 2019-08-14 248 0 并发编程

并发编程(三).png

并发编程(三)    >>>思维导图>>>博客园

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')
'''


本文标题:【并发编程】锁/线程队列/信号量/Event事件
本文链接:https://zhong-er.com/post/63.html
作者授权:除特别说明外,本文由 從出茳湖 原创编译并授权 中二青年 刊载发布。
版权声明:本文使用「署名-非商业性使用-相同方式共享 4.0 国际」创作共享协议,转载或使用请遵守署名协议。

评论

登录
用户名
密码
注册
用户名
密码
确认密码
邮箱
获取邀请码
邀请码
验证码
找回密码
用户名
邮箱
※ 重置链接将发送到邮箱
召唤伊斯特瓦尔