Python: 线程同步原语

一、概述

当多个线程同时访问共享资源时，可能会发生竞态条件（Race Condition），导致数据不一致或程序异常崩溃等问题。而线程同步就是为了防止竞态条件而采取的一些机制。Python提供了一些线程同步原语（Synchronization Primitives），用于协调线程之间的访问。本文将介绍Python中的几种常用线程同步原语，包括锁、信号量、事件和条件变量。

二、锁

锁是最常用的线程同步机制，在Python中通过threading模块中的Lock类来实现。在使用锁时，一个线程获得了锁之后，其他线程不能再获得该锁，直到该线程释放锁为止。

import threading

num = 0 # 共享变量
lock = threading.Lock() # 创建锁对象

# 线程函数
def func():
    global num
    for i in range(100000):
        lock.acquire() # 获取锁
        num += 1 # 对共享变量进行操作
        lock.release() # 释放锁

t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t1.start()
t2.start()
t1.join()
t2.join()

print(num) # 输出结果为200000

三、信号量

信号量是一种比锁更为通用的线程同步原语，在Python中通过threading模块中的Semaphore类来实现。在使用信号量时，可以设置一个计数器，每当一个线程获取了信号量时，计数器就会减1；而每当一个线程释放信号量时，计数器就会加1。当计数器为0时，其他线程将被阻塞。

import threading

num = 0 # 共享变量
sem = threading.Semaphore(1) # 创建信号量对象，初始值为1

# 线程函数
def func():
    global num
    for i in range(100000):
        sem.acquire() # 获取信号量
        num += 1 # 对共享变量进行操作
        sem.release() # 释放信号量

t1 = threading.Thread(target=func)
t2 = threading.Thread(target=func)
t1.start()
t2.start()
t1.join()
t2.join()

print(num) # 输出结果为200000

四、事件

事件是用于线程之间通信的一种机制，在Python中通过threading模块中的Event类来实现。事件对象有一个内部的标志位，默认为False，可以通过set()方法将其设置为True，也可以通过clear()方法将其设置为False；可以通过wait()方法来等待事件的发生。

import threading

event = threading.Event()

# 子线程函数
def sub_thread():
    print('sub_thread: wait for event')
    event.wait() # 等待事件的发生
    print('sub_thread: event is set')

# 主线程函数
def main_thread():
    print('main_thread: start')
    event.set() # 设置事件
    print('main_thread: event is set')
    sub_thread()
    
t = threading.Thread(target=main_thread)
t.start()
t.join()

五、条件变量

条件变量是一种更为复杂的线程同步机制，在Python中通过threading模块中的Condition类来实现。条件变量通常与锁一起使用，当某个条件不满足时，该线程就会进入阻塞状态；而当某个条件满足时，该线程就会被唤醒。

import threading

num = 0 # 共享变量
condition = threading.Condition()

# 生产者线程函数
def producer():
    global num
    for i in range(10):
        with condition:
            # 检查条件
            while num >= 5:
                print('producer: wait for condition')
                condition.wait()
            # 生产数据
            num += 1
            print('producer: produce data, num =', num)
            # 唤醒消费者
            condition.notify()

# 消费者线程函数
def consumer():
    global num
    for i in range(10):
        with condition:
            # 检查条件
            while num <= 0:
                print('consumer: wait for condition')
                condition.wait()
            # 消费数据
            num -= 1
            print('consumer: consume data, num =', num)
            # 唤醒生产者
            condition.notify()

t1 = threading.Thread(target=producer)
t2 = threading.Thread(target=consumer)
t1.start()
t2.start()
t1.join()
t2.join()

六、总结

线程同步是多线程编程中必不可少的部分，而在Python中，使用线程同步机制可以通过Lock、Semaphore、Event和Condition等几种不同的方式来实现。我们在编写多线程程序时，应当充分考虑线程之间的同步和通信，以确保程序的正确性。