跳到主要内容

操作系统线程同步

介绍​

在多线程编程中，多个线程可能会同时访问共享资源（如变量、文件或内存）。如果没有适当的同步机制，可能会导致竞争条件（Race Condition），即多个线程以不可预测的顺序访问共享资源，从而导致程序行为异常或数据损坏。为了避免这种情况，操作系统提供了线程同步机制。

线程同步的核心目标是确保多个线程在访问共享资源时能够有序地进行，从而避免冲突和数据不一致。

为什么需要线程同步？​

假设有两个线程同时尝试更新一个共享变量：

python
shared_variable = 0

def increment():
    global shared_variable
    for _ in range(100000):
        shared_variable += 1

thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)

thread1.start()
thread2.start()
thread1.join()
thread2.join()

print(shared_variable)

理想情况下，shared_variable 的最终值应该是 200000。但由于线程竞争，实际结果可能小于 200000。这是因为 shared_variable += 1 操作不是原子的，可能会被其他线程中断。

线程同步机制​

操作系统提供了多种线程同步机制，以下是常见的几种：

1. 互斥锁（Mutex）​

互斥锁是最常用的同步机制。它确保同一时间只有一个线程可以访问共享资源。

python
import threading

shared_variable = 0
lock = threading.Lock()

def increment():
    global shared_variable
    for _ in range(100000):
        lock.acquire()
        shared_variable += 1
        lock.release()

thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)

thread1.start()
thread2.start()
thread1.join()
thread2.join()

print(shared_variable)
备注

注意：使用互斥锁时，必须确保在访问共享资源后释放锁，否则会导致死锁。

2. 信号量（Semaphore）​

信号量是一种更通用的同步机制，允许多个线程同时访问共享资源，但限制同时访问的线程数量。

python
import threading

shared_variable = 0
semaphore = threading.Semaphore(2)  # 允许最多 2 个线程同时访问

def increment():
    global shared_variable
    for _ in range(100000):
        semaphore.acquire()
        shared_variable += 1
        semaphore.release()

thread1 = threading.Thread(target=increment)
thread2 = threading.Thread(target=increment)
thread3 = threading.Thread(target=increment)

thread1.start()
thread2.start()
thread3.start()
thread1.join()
thread2.join()
thread3.join()

print(shared_variable)

3. 条件变量（Condition Variable）​

条件变量用于在特定条件下同步线程。它通常与互斥锁一起使用。

python
import threading

shared_queue = []
lock = threading.Lock()
condition = threading.Condition(lock)

def producer():
    for i in range(5):
        with condition:
            shared_queue.append(i)
            condition.notify()  # 通知消费者
        print(f"Produced: {i}")

def consumer():
    for _ in range(5):
        with condition:
            while not shared_queue:
                condition.wait()  # 等待生产者通知
            item = shared_queue.pop(0)
        print(f"Consumed: {item}")

producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

producer_thread.start()
consumer_thread.start()
producer_thread.join()
consumer_thread.join()
提示

提示：条件变量非常适合生产者-消费者模型，其中消费者需要等待生产者生成数据。

实际应用场景​

1. 数据库连接池​

在多线程环境中，数据库连接是有限的资源。使用信号量可以限制同时访问数据库的线程数量，从而避免资源耗尽。

2. 多线程文件处理​

当多个线程需要同时写入同一个文件时，使用互斥锁可以确保文件内容不会被破坏。

3. 任务调度​

在任务调度系统中，条件变量可以用于协调任务的执行顺序，确保任务在满足特定条件时才开始执行。

总结​

线程同步是多线程编程中不可或缺的一部分。通过使用互斥锁、信号量和条件变量等机制，可以有效地避免竞争条件，确保程序的正确性和稳定性。

警告

警告：不正确的同步机制可能导致死锁或性能问题。在设计多线程程序时，务必仔细考虑同步策略。

附加资源​

练习​

  1. 修改上面的 increment 函数，使用信号量代替互斥锁，并观察结果。
  2. 实现一个生产者-消费者模型，使用条件变量协调线程。
  3. 研究并实现一个简单的死锁场景，然后尝试解决它。