五、线程锁

1，基本介绍

import threading

number = 0

def plus():
    global number       # global声明此处的number是外面的全局变量number
    for _ in range(1000000):    # 进行一个大数级别的循环加一运算
        number += 1

for i in range(2):  # 用2个子线程，就可以观察到脏数据
    t = threading.Thread(target=plus)
    t.start()

time.sleep(2)       # 等待2秒，确保2个子线程都已经结束运算。
print("主线程执行完毕后，number = ", number)

2，Lock（同步锁）

import threading
import time

number = 0
lock = threading.Lock() # 创建一个同步锁对象

def plus():
    global number       # global声明此处的number是外面的全局变量number
    for _ in range(1000000):    # 进行一个大数级别的循环加一运算
        lock.acquire()        # 开始加锁
        number += 1
        lock.release()        # 释放锁

for i in range(2):  # 用2个子线程，就可以观察到脏数据
    t = threading.Thread(target=plus)
    t.start()

time.sleep(2)       # 等待2秒，确保2个子线程都已经结束运算。
print("主线程执行完毕后，number = ", number)

3，RLock（递归锁）

import threading
import time

number = 0
lock = threading.RLock() # 创建一个递归锁对象

def plus():
    global number       # global声明此处的number是外面的全局变量number
    for _ in range(1000000):    # 进行一个大数级别的循环加一运算
        lock.acquire()        # 开始加锁
        lock.acquire()
        number += 1
        lock.release()        # 释放锁
        lock.release()

for i in range(2):  # 用2个子线程，就可以观察到脏数据
    t = threading.Thread(target=plus)
    t.start()

time.sleep(2)       # 等待2秒，确保2个子线程都已经结束运算。
print("主线程执行完毕后，number = ", number)

4，Condition（条件锁）

import threading
from time import sleep

currentRunThreadNumber = 0 # 当前运行的线程数量
maxSubThreadNumber = 10 # 子线程总数

def task():
    global currentRunThreadNumber
    thName = threading.currentThread().name

    condLock.acquire()  # 上锁
    print("线程就绪并等待 : %s" % thName)

    condLock.wait()  # 暂停线程运行、等待唤醒
    currentRunThreadNumber += 1
    print("线程开始运行 : %s" % thName)

    condLock.release()  # 解锁


if __name__ == "__main__":
    condLock = threading.Condition() # 创建一个条件锁

    # 创建子线程
    for i in range(maxSubThreadNumber):
        subThreadIns = threading.Thread(target=task)
        subThreadIns.start()

    # 通过循环进行设置每次通知的线程数量
    while currentRunThreadNumber < maxSubThreadNumber:
        notifyNumber = int(
            input("请输入需要通知运行的线程数量："))

        condLock.acquire() # 上锁
        condLock.notify(notifyNumber)  # 放行
        condLock.release() # 解锁

    print("主线程结束")

（2）上面样例程序运行后会启动 10 个子线程，并且会立即将 10 个子线程设置为等待状态。然后我们可以发送一个或者多个通知，来恢复被等待的子线程继续运行。运行结果如下：

5，Event（事件锁）

import threading
from time import sleep

maxSubThreadNumber = 3 # 最大子线程数量
event = threading.Event() # 创建一个事件对象

# 子线程函数
def task():
    while True:
        thName = threading.currentThread().name
        if event.is_set():      # 判断当前是否"绿灯放行"状态
            print("%s 线程运行中。" % thName)
            sleep(1)
        else:
            print("红灯亮, %s 停止运行." % thName) 
            event.wait()
            print("%s 看到绿灯亮了，继续运行。" % thName)
    #print("线程 %s 结束" % thName) 
    
if __name__ == "__main__":
    for i in range(maxSubThreadNumber):
      subThreadIns = threading.Thread(target = task)
      subThreadIns.start()
    event.set()# 设置为绿灯
    sleep(3)
    event.clear()# 设置为红灯 
    sleep(3)
    event.set()# 设置为绿灯

（2）上面是一个模拟红绿灯控制汽车通行的例子，运行结果如下：

6，Semaphore（信号量锁）

import time
import threading

# 设置允许5个线程同时运行的信号量锁
semaphore = threading.BoundedSemaphore(5)

def run(n):
    semaphore.acquire() # 获取信号量
    print("run the thread: %s" % n, "at:", time.ctime())
    time.sleep(5)
    semaphore.release() # 释放信号量

# 创建20个线程
for i in range(20):
    t = threading.Thread(target=run, args=(i,))
    t.start()

（2）运行结果如下，可以看到5个一批的线程被放行：

六、with 语句

1，基本介绍

（2）with语句的使用格式如下：

with some_lock:
    # 执行任务...

（3）其相当于如下代码，可以看到及时出现异常或者错误也能够正常释放锁：

some_lock.acquire()
try:
    # 执行任务..
finally:
    some_lock.release()

2，使用样例

import threading
import time
 
number = 0
lock = threading.Lock() # 创建一个同步锁对象
 
def plus():
    global number       # global声明此处的number是外面的全局变量number
    for _ in range(1000000):    # 进行一个大数级别的循环加一运算
        with lock: # 自动加锁/解锁
            number += 1
 
for i in range(2):  # 用2个子线程，就可以观察到脏数据
    t = threading.Thread(target=plus)
    t.start()
 
time.sleep(2)       # 等待2秒，确保2个子线程都已经结束运算。
print("主线程执行完毕后，number = ", number)

七、全局解释器锁（GIL）

1，Python 多线程的特点

（2）Python 针对不同类型的任务，多线程执行效率是不同的：

2，什么是 GIL？

（3）GIL 只在 CPython 解释器中才有，因为 CPython 调用的是 c 语言的原生线程，不能直接操作 cpu，只能利用 GIL 保证同一时间只能有一个线程拿到数据。在 PyPy 和 JPython 中没有 GIL。

八、死锁

1，什么是死锁?

2，产生死锁的四个必要条件

3，常见的3种死锁的类型

（2）动态的锁顺序死锁：指两个线程调用同一个方法时，传入的参数颠倒造成的死锁。 （3）协作对象之间的死锁：如果在持有锁时调用某个外部方法，那么将可能出现死锁问题。在这个外部方法中可能会获得其他锁，或者阻塞时间过长，导致其他线程无法及时获得当前被持有的锁。为了避免这种危险的情况发生，我们使用开放调用。

4，避免死锁的方法

（2）使用定时锁。即加上一个超时时间，若一个线程没有在给定的时限内成功获得所有需要的锁，则会进行回退并释放所有已经获得的锁，然后等待一段随机的时间再重试。
（3）银行家算法。是检查申请人对资源的最大需求量，如果现在各种资源都能满足的申请人的要求，就能满足申请人的要求，申请人很快就能完成计算，释放占有的资源，保证系统的所有过程都能完成，可以避免死锁。