互斥锁

在Python中，可以使用互斥锁（Mutex）来实现线程之间的互斥访问，保证共享资源的安全性。互斥锁可以确保在任何时刻只有一个线程可以持有锁，并且其他线程必须等待锁的释放才能继续执行。

步骤

1. 创建互斥锁对象：

lock = threading.Lock()

通过threading.Lock()函数创建一个互斥锁对象。

2. 获取互斥锁：

lock.acquire()

调用acquire()方法获取互斥锁。如果互斥锁已经被其他线程占用，则当前线程将被阻塞，直到互斥锁被释放。

3. 释放互斥锁：

lock.release()

示例

 1 import threading
 2 
 3 # 全局变量
 4 g_num = 0
 5 
 6 
 7 # 对g_num进行加操作
 8 def sum_num1():
 9     # 上锁
10     mutex.acquire()
11 
12     for i in range(1000000):
13         global g_num
14         g_num += 1
15 
16     # 解锁
17     mutex.release()
18 
19     print("g_num1:", g_num)
20 
21 
22 # 对g_num进行加操作
23 def sum_num2():
24     # 上锁
25     mutex.acquire()
26 
27     for i in range(1000000):
28         global g_num
29         g_num += 1
30 
31     # 解锁
32     mutex.release()
33 
34     print("g_num2:", g_num)
35 
36 
37 if __name__ == '__main__':
38     # 创建锁
39     mutex = threading.Lock()
40     # 创建子线程
41     sum1_thread = threading.Thread(target=sum_num1)
42     sum2_thread = threading.Thread(target=sum_num2)
43 
44     # 启动线程
45     sum1_thread.start()
46     sum2_thread.start()
47     # 等待子线程结束
48     sum1_thread.join()
49     sum2_thread.join()
50     print(f"g_num最终值:{g_num}")

输出：

g_num1: 1000000
g_num2: 2000000
g_num最终值:2000000

推荐示例-with语句

 1 '''
 2 在Python中，可以使用互斥锁（Mutex）来实现线程之间的互斥访问，保证共享资源的安全性。
 3 互斥锁可以确保在任何时刻只有一个线程可以持有锁，并且其他线程必须等待锁的释放才能继续执行。
 4 
 5 互斥锁使用3步骤:  推荐使用with语句
 6     1. 创建互斥锁对象
 7     2. 获取互斥锁
 8     3. 释放锁
 9 
10 '''
11 import threading
12 
13 # 全局变量
14 count = 0
15 # 1. 创建互斥锁对象，定义未全局变量，让多线程共享。要保证上的是同一把锁，否则锁不住
16 lock = threading.Lock()
17 
18 # 线程函数
19 def increment():
20     global count
21     for _ in range(100000):
22         with lock:  # 自动上锁、解锁
23             count += 1
24 
25 if __name__ == '__main__':
26     # 创建两个线程
27     thread1 = threading.Thread(target=increment)
28     thread2 = threading.Thread(target=increment)
29 
30     # 启动线程
31     thread1.start()
32     thread2.start()
33 
34     # 等待线程结束
35     thread1.join()
36     thread2.join()
37 
38     # 打印最终结果
39     print("Final count:", count)