03. 多线程锁

1. 互斥锁

1. 线程之间是进行随机调度，多个线程同时修改同一条数据时可能会出现脏数据。
2. 因此出现了线程锁，即同一时刻允许一个线程执行操作。线程锁用于锁定资源。
3. 由于线程之间是进行随机调度，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不可预期，我们也称此为“线程不安全”。

#!/usr/bin/env python
# coding:utf-8

from threading import Thread, Lock
import time


def work():
    global num
    lock.acquire()
    tmp = num
    time.sleep(0.1)
    num = tmp - 1
    lock.release()
    print(f'num: {num}')


if __name__ == '__main__':
    lock = Lock()
    num = 100
    t_l = []
    for i in range(100):
        t = Thread(target=work)
        t_l.append(t)
        t.start()
    for p in t_l:
        p.join()

2. 递归锁

1. RLcok类的用法和Lock类一模一样，但它支持嵌套，在多个锁没有释放的时候一般会使用RLcok类。

#!/usr/bin/env python
# coding:utf-8

import threading
import time


def work(lock):
    global global_num
    lock.acquire()
    global_num += 1
    time.sleep(1)
    print(f'global_num: {global_num}')
    lock.release()


if __name__ == '__main__':
    global_num = 0
    lock = threading.RLock()
    for i in range(10):
        t = threading.Thread(target=work, args=(lock,))
        t.start()