Python入门学习 DAY36（GIL全局解释器锁 死锁与递归锁 信号量 Event 线程queue）

Python入门学习

DAY36

今日内容:

GIL全局解释器锁

死锁与递归锁

信号量

Event事件

线程queue
 

1. GIL全局解释器锁(Global Interpreter Lock)

GIL理论:http://www.cnblogs.com/linhaifeng/articles/7449853.html

什么是GIL全局解释器锁

GIL本质就是互斥锁,相当于执行权限,每个进程内都会存在GIL,同一进程的多个线程

必须抢到GIL之后才能使用Cpython解释器来执行自己的代码.即同一进程内的多个线程无法实现并行

但是可以实现并发

为何要有GIL

因为Cpython解释器的垃圾回收机制不是线程安全的

在GIL存在的情况下,如何处理并发呢?

分二中情况

计算密集型:

from multiprocessing import Process
from threading import Thread
import os, time

def work():
    res = 0
    for i in range(10000000):
        res+=i

if __name__=='__main__':
    l = []
    print(os.cpu_count())  # os.cpu_count() 获得cpu核数
    start = time.time()
    for i in range(4):
        p = Process(target = work)   # 可以对比进程和线程的运行时间比较什么情况用什么方法
        # p = Thread(target = work)
        l.append(p)
        p.start()

    for p in l:
        p.join()

    stop = time.time()
    print('run time is %s' % (stop - start)) # 打印运行时间

IO密集型:

from multiprocessing import Process
from threading import Thread
import  time

def work():
    time.sleep(2) # time.sleep 也可看做io操作

if __name__ == '__main__':
    l = []
    start = time.time()
    for i in range(100):
        # p = Process(target=work)
        p = Thread(target=work)
        l.append(p)
        p.start()

    for p in l:
        p.join()

    stop = time.time()
    print('run time is %s' % (stop - start))  # 打印运行时间

 

死锁与递归锁

死锁现象

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

死锁现象举例

from threading import Thread, Lock
import time

mutexA = Lock()
mutexB = Lock()


class Mythread(Thread):
    def run(self):
        self.foo()
        self.bar()

    def foo(self):
        mutexA.acquire()
        print('%s 获取 A 锁' % self.name)
        mutexB.acquire()
        print('%s 获取 B 锁' % self.name)
        mutexB.release()
        mutexA.release()

    def bar(self):
        mutexB.acquire()
        print('%s 获取 B 锁' % self.name)
        time.sleep(0.1)  # 当此处睡眠后,会导致死锁现象的产生
        mutexA.acquire()
        print('%s 获取 A 锁' % self.name)
        mutexA.release()
        mutexB.release()


if __name__ == '__main__':
    for i in range(10):
        t = Mythread()
        t.start()

递归锁

可以解决死锁现象，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程

所有的acquire都被release，其他的线程才能获得资源。

from threading import Thread, RLock
import time

mutexA = mutexB = RLock()

class Mythread(Thread):
    def run(self):
        self.foo()
        self.bar()

    def foo(self):
        mutexA.acquire()
        print('%s 获取 A 锁' % self.name)
        mutexB.acquire()
        print('%s 获取 B 锁' % self.name)
        mutexB.release()
        mutexA.release()

    def bar(self):
        mutexB.acquire()
        print('%s 获取 B 锁' % self.name)
        time.sleep(0.1)
        mutexA.acquire()
        print('%s 获取 A 锁' % self.name)
        mutexA.release()
        mutexB.release()

if __name__ == '__main__':
    for i in range(10):
        t = Mythread()
        t.start()

 

信号量

同进程的一样

Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

例：同时只有5个线程可以获得semaphore,即可以限制最大连接数为5

from threading import Thread,Semaphore
import time,random

sh = Semaphore(5)

def task(name):
    # 假设餐厅最多只能有5人吃饭,其他人想吃饭得等有人吃好
    sh.acquire()
    print('%s 号顾客  正在用餐...' %name)
    time.sleep(random.randint(1,3)) # 模拟用餐时间
    print('%s 号顾客  用餐结束' %name)
    sh.release()

if __name__=='__main__':
    for i in range(10):
        t = Thread(target=task,args=(i,))
        t.start()

 

 

Event事件

同进程的一样

线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。 对象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行

event.isSet()：返回event的状态值；

event.wait()：如果 event.isSet()==False将阻塞线程；

event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；

event.clear()：恢复event的状态值为False。

例:

from threading import Thread, Event
import time,random

event = Event()


def light():
    # 模拟红绿灯
    print('红灯...')
    time.sleep(3)  # 模拟红灯时间
    print('绿灯...')
    event.set()


def car(name):
    print('%s 号车正在等红灯...' % name)
    event.wait()
    time.sleep(random.randint(1,3))
    print('%s 号车正在行驶...' % name)


if __name__ == '__main__':
    l = Thread(target=light)
    l.start()

    for i in range(10):
        t = Thread(target=car, args=(i,))
        t.start()

线程queue

queue队列 ：使用import queue，用法与进程Queue一样

queue.Queue() 先进先出

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

queue.LifoQueue()  先进后出

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

queue.PriorityQueue() #按优先级输出

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

 

以上为本次学习的内容