并发编程(三) GIL锁和其他知识

1.全局解释器锁GIL

什么是GIL

　　GIL是全局解释器锁他规定了每个线程在被CPU执行前都要获得一个GIL,并且同一时刻只有一个线程被执行

为什么要有GIL

　　因为CPython解释器的内存管理不是线程安全的,所以在CPython中增加的一个GIL锁

线程释放GIL锁的情况

　　在I/O操作等会引起阻塞状态的操作时,会暂时释放GIL,其他线程可以获取GIL继续执行

python的多线程和多进程的使用场景

　　1.当CPU处于多任务计算密集型的情况下

　　　　单核:两者差不多,但是多线程更加省资源

　　　　多核:由于多线程不能利用多核的优势,所以使用多进程更有优势

　　2.当CPU处于多任务I/O密集型的情况下

　　　　单核:和上述一样,多线程更省资源

　　　　多核:由于I/O密集型的任务耗费的时间大部分在I/O操作上,并且cpu在阻塞状态时可以暂时释放GIL,所以还是多线程更省资源(开启进程是耗费资源,当需要进行的任务过多,多进程耗费的时间会大大超过多线程)

# 计算密集型
from multiprocessing import Process
import os,time
def work():
    res=0
    for i in range(100000000):
        res*=i


if __name__ == '__main__':
    l=[]
    print(os.cpu_count())  # 本机为8核
    start=time.time()
    for i in range(6):
        p=Process(target=work)  # 在当前机器上,多进程耗时 9.134473323822021s
        # p=Thread(target=work)  # 在当前机器上,多线程耗时 51.49368095397949s
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

from multiprocessing import Process
import os,time
def work():
    time.sleep(2)

if __name__ == '__main__':
    l=[]
    print(os.cpu_count()) #本机为8核
    start=time.time()
    for i in range(400):
        p=Process(target=work)  # 在当前机器上,多进程耗时12.091996908187866s多,大部分时间耗费在创建进程上
        # p=Thread(target=work)  # 在当前机器上,多线程耗时2.050579309463501s
        l.append(p)
        p.start()
    for p in l:
        p.join()
    stop=time.time()
    print('run time is %s' %(stop-start))

由上述计算结果表明,一般情况下,只有当多核计算机在执行计算密集型操作时使用多进程,但是这不是一成不变的,要视具体情况而定,并且实际开发中我们都是多进程+多线程结合使用

 多线程I/O操作时不会耗费时间

from threading import Thread
import time

n = 100

def task():
    global n
    temp = n
    time.sleep(1)
    '''
    模拟I/O操作,当I/O进行时i,线程会暂时释放GIL,其他线程可以获得,他们都进行到这一步,n = 100
    I/O操作结束,开始执行每个线程的n-1得到的都是99,所以结果是99
    
    如果没有I/O操作,那因为GIL锁的原因,每个线程都需要执行完才会释放GIL,
    故第二个线程获得的n是第一个线程-1后的结果,所以结果是0
    '''
    n = temp - 1

l = []
for i in range(100):
    t = Thread(target=task)
    t.start()
    l.append(t)
for t in l:
    t.join()
print(n)

time模拟I/O操作,当I/O进行时i,线程会暂时释放GIL,其他线程可以获得,他们都进行到这一步,n = 100I/O操作结束,开始执行每个线程的n-1得到的都是99,所以结果是99

如果没有I/O操作,那因为GIL锁的原因,每个线程都需要执行完才会释放GIL,故第二个线程获得的n是第一个线程-1后的结果,所以结果是0

 

2.死锁

什么是死锁

　　指的是两个或多个进程或线程在执行过程中,因争夺资源而造成了一种互相等待的问题,如果没有外力的作用,它们都无法执行下去,这时就是处于死锁状态

from threading import Thread,Lock

mutex = Lock()

def task():
    mutex.acquire()
    print('hello world')
    mutex.acquire()  
    '''
    想要获得这个锁,需要等到上面的人释放锁,但是他想要释放锁必须先获得锁,这就形成了死锁
    '''
    print('hi')
    mutex.release()
    mutex.release()

t = Thread(target=task)
t.start()

线程1开始执行,time.sleep(1)模拟I/O操作,当第一个线程执行到这时,暂停了1秒,释放了GIL锁

线程2开始执行,当线程2抢到A锁,需要抢B锁,但是B锁在线程1中,这时线程1开始执行,需要故两个线程互相等待,形成了死锁

3.递归锁

什么是递归锁

　　RLock递归锁,可以被第一个抢到锁的人连续的acquire()和release()每次acquire,身上的计数加1,每次release身上的计数减1,只要身上的引用计数不为0,其他任何人都不能抢

from threading import Thread,RLock

mutex = RLock()

def task():
    mutex.acquire()
    print('hello world')
    mutex.acquire()
    '''
    使用递归锁,可以避免形成死锁
    '''
    print('hi')
    mutex.release()
    mutex.release()

t = Thread(target=task)
t.start()

 

from threading import Thread,Lock,RLock
import time

# mutexA = Lock()
# mutexB = Lock()

mutexA = RLock()
'''
RLock递归锁,可以被第一个抢到锁的人连续的acquire()和release()
每次acquire,身上的计数加1,每次release身上的计数减1
只要身上的引用计数不为0,其他任何人都不能抢
'''

class MyThread(Thread):
    def run(self):
        self.task()
        self.task1()

    def task(self):
        mutexA.acquire()
        print('%s抢到了A锁'%self.name)
        mutexA.acquire()
        print('%s抢到了B锁'%self.name)
        mutexA.release()
        print('%s释放了A锁' % self.name)
        mutexA.release()
        print('%s释放了B锁' % self.name)

    def task1(self):
        mutexA.acquire()
        print('%s抢到了B锁' % self.name)
        time.sleep(1)
        mutexA.acquire()
        print('%s抢到了A锁' % self.name)
        mutexA.release()
        print('%s释放了A锁' % self.name)
        mutexA.release()
        print('%s释放了B锁' % self.name)

for i in range(4):
    t = MyThread()
    t.start()

递归锁可以一定程度上解决死锁

4.信号量

一个互斥锁能控制只有抢到锁的线程在执行锁内的操作,

而信号量可以控制指定数量的线程执行锁内的操作

from threading import Thread,Semaphore
import time

s = Semaphore(3)  # 允许最大3个线程同时执行

def task(i):
    s.acquire()
    print('%s正在执行'%i)
    time.sleep(1)
    s.release()

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

5.event事件

event通过标志位来判断运行的状态

Event用法：
event=threading.Event() #设置一个事件实例
event.set() #设置标志位
event.clear() #清空标志位
event.wait()  #等待设置标志位
event.is_set  #判断标志位是否被设置

from threading import Thread,Event
import time
import random

e = Event()  # 生成一个event对象

def jump():
    print('飞机起飞,准备跳伞')
    time.sleep(1.1)
    print('倒计时5秒,机舱打开')
    for i in range(6):
        print('
%s'%(5-i),end= '')
        time.sleep(1)
    e.set()  # 发送信号
    print('')
    print('机舱打开,开始跳伞')


def people(i):
    time.sleep(random.random())
    print('伞兵%s号,准备完毕'%i)
    e.wait()  # 等待信号
    time.sleep(random.random())
    print('伞兵%s号,开始跳伞'%i)

t = Thread(target=jump)
t.start()

for i in range(1,10):
    t1 = Thread(target=people,args=(i,))
    t1.start()

6.队列补充

队列是管道+锁,使用队列就不需要自己手动操作锁的问题
因为锁操作的不好极容易产生死锁现象

队列:
    import queue  # 导入模块

    queue.Queue()  # 生成队列对象,先进先出
    queue.LifoQueue()  # 生成堆栈对象,后进先出
    queue.PriorityQueue()  # 优先级队列,数字越小,优先级越高

from queue import Queue,LifoQueue,PriorityQueue

q = Queue()  # 生成队列对象,先进先出

q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())

q = LifoQueue()  # 堆栈,后进先出
q.put(1)
q.put(2)
q.put(3)
print(q.get())
print(q.get())
print(q.get())

q = PriorityQueue()  # 优先级队列,根据传值的大小,小的先出队
# 传入元组,第一个值限制了取值时的优先级
q.put((1,1))
q.put((1,5))
q.put((1,3))
print(q.get())
print(q.get())
print(q.get())

 32