python之线程(锁相关)

1、线程互斥锁

from threading import Thread, Lock
import time

num = 100

def task(mutex):
    global num
    # 在修改数据的时候,加锁
    mutex.acquire()
    tmp = num
    time.sleep(0.1)
    num = tmp - 1
    # 修改完以后,释放锁,其它线程就能再次抢到锁
    mutex.release()

if __name__ == '__main__':
    mutex = Lock()
    l = []
    for i in range(10):
        t = Thread(target=task, args=(mutex,))
        t.start()
        l.append(t)
    for x in l:
        x.join()
    print(num)

2、GIL全局解释器锁

GIL本质就是一把互斥锁,既然是互斥锁，所有互斥锁的本质都一样,都是将并发运行变成串行,以此来控制同一时间内共享数据只能被一个任务所修改,进而保证数据安全。
可以肯定的一点是: 保护不同的数据的安全,就应该加不同的锁。

1、python的解释器有很多，cpython，jpython，pypy(python写的解释器)
2、python的库多，库都是基于cpython写起来的，其他解释器没有那么多的库
3、cpython中有一个全局大锁，每条线程要执行，必须获取到这个锁
4、为什么会有这个锁呢？python的垃圾回收机制，存在一种极端情况，cpython的垃圾后回收机制(垃圾回收线程)会在变量刚创建的时候，该变量还没来得及引用任何值，此时垃圾回收线程会把该变量当成垃圾直接回收，此时数据不安全
5、python的多线程其实就是单线程
6、某个线程想要执行，必须先拿到GIL，我们可以把GIL看作是“通行证”，并且在一个python进程中，GIL只有一个。拿不到通行证的线程，就不允许进入CPU执行
7、总结: cpython解释器中有一个全局锁(GIL)，线程必须获取到GIL才能执行，我们开的多线程，不管有几个cpu，同一时刻，只有一个线程在执行(python的多线程，不能利用多核优势)
8、如果是io密集型操作:开多线程
9、如果是计算密集型:开多进程
以上两句话(8和9)，只针对与cpython解释器

3、验证GIL锁的存在方式

from multiprocessing import Process
from threading import Thread

def task():
    while True:
        pass

if __name__ == '__main__':
    for i in range(4):
        t = Thread(target=task)  # 因为有GIL锁，同一时刻，只有一条线程执行，所以cpu不会满
        t = Process(target=task)  # 由于是多进程，进程中的线程会被cpu调度执行，4个cpu全在工作，就会跑满
        t.start()

4、GIL与普通互斥锁的区别

from threading import Thread, Lock
import time

num = 100

def task(mutex):
    global num
    mutex.acquire()
    tmp = num
    time.sleep(1)
    num = tmp - 1
    mutex.release()

if __name__ == '__main__':
    mutex = Lock()
    list = []
    for i in range(10):
        obj = Thread(target=task, args=(mutex,))
        obj.start()
        # obj.join()  如果直接在此处加join会变成串行
        list.append(obj)
    for i in list:
        i.join()
    print(num)  # 90

结论: GIL锁是不能保证数据的安全，普通互斥锁是保证数据安全

5、死锁现象(哲学家就餐问题)

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

from threading import Thread, Lock
import time

# 同一把锁
# mutexA = Lock()
# mutexB = mutexA

mutexA = Lock()
mutexB = Lock()

def task1(name):
    mutexA.acquire()
    print('{}获得了A锁'.format(name))
    mutexB.acquire()
    print('{}获得了B锁'.format(name))
    print('{}执行程序1'.format(name))
    mutexB.release()
    print('{}释放了B锁'.format(name))
    mutexA.release()
    print('{}释放了A锁'.format(name))

def task2(name):
    mutexB.acquire()
    print('{}获得了B锁'.format(name))
    time.sleep(2)
    mutexA.acquire()
    print('{}获得了A锁'.format(name))
    print('{}执行程序2'.format(name))
    mutexA.release()
    print('{}释放了A锁'.format(name))
    mutexB.release()
    print('{}释放了B锁'.format(name))

if __name__ == '__main__':
    name_list = ['张三', '李四', '王五']
    for name in name_list:
        obj = Thread(target=task1, args=(name,))
        obj1 = Thread(target=task2, args=(name,))
        obj.start()
        obj1.start()

执行结果:
张三获得了A锁
张三获得了B锁
张三执行程序1
张三释放了B锁
张三释放了A锁
张三获得了B锁
李四获得了A锁

6、递归锁(可重入锁)

递归锁(可重入锁)，同一个人可以多次acquire，每acquire一次，内部计数器加1，每relaese一次，内部计数器减一
只要计数器不为0，其他人都拿不到这把锁

from threading import Thread, RLock
import time

# 使用可重入锁解决(同一把锁)
# mutexA = RLock()
# mutexB = mutexA

mutexA = mutexB = RLock()

def task1(name):
    mutexA.acquire()
    print('{}获得了A锁'.format(name))
    mutexB.acquire()
    print('{}获得了B锁'.format(name))
    print('{}执行程序1'.format(name))
    mutexB.release()
    print('{}释放了B锁'.format(name))
    mutexA.release()
    print('{}释放了A锁'.format(name))

def task2(name):
    mutexB.acquire()
    print('{}获得了B锁'.format(name))
    time.sleep(2)
    mutexA.acquire()
    print('{}获得了A锁'.format(name))
    print('{}执行程序2'.format(name))
    mutexA.release()
    print('{}释放了A锁'.format(name))
    mutexB.release()
    print('{}释放了B锁'.format(name))

if __name__ == '__main__':
    name_list = ['张三', '李四', '王五']
    for name in name_list:
        obj = Thread(target=task1, args=(name,))
        obj1 = Thread(target=task2, args=(name,))
        obj.start()
        obj1.start()

7、信号量Semaphore

Semaphore: 信号量可以理解为多把锁，同时允许多个线程来更改数据

from threading import Thread, Semaphore
import time
import random

sm = Semaphore(4)

def task(n):
    sm.acquire()
    print('用户{}正在学习...'.format(n))
    time.sleep(random.randint(1, 3))
    sm.release()

if __name__ == '__main__':
    for i in range(1, 21):
        obj = Thread(target=task, args=(i,))
        obj.start()