码迷,mamicode.com
首页 > 其他好文 > 详细

并发编程(三)

时间:2019-08-14 16:50:15      阅读:85      评论:0      收藏:0      [点我收藏+]

标签: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)
View Code

死锁与递归锁

所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁

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()
View Code

信号量

信号量可能在不同的领域中 对应不同的知识点

信号量通过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()
View Code

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()
View Code

线程队列

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
‘‘‘
View Code

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
‘‘‘
View Code

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‘)
‘‘‘
View Code

END

并发编程(三)

标签:mutex   请求   image   width   second   优先级   UNC   模块   多核   

原文地址:https://www.cnblogs.com/renvip/p/11352646.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!