并发编程(三)

并发编程(三)    >>>思维导图>>>中二青年

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