多线程编程陷阱：Python中常见并发问题示例

原创小鱼儿 2025-02-13 06:48 54阅读 0赞

在Python的多线程编程中，可能会遇到一些常见的并发问题。以下是一些示例：

1. **死锁**：当两个或更多的线程互相等待对方释放资源时，就会发生死锁。例如：

```python
import threading

# 线程A需要B的资源，同时B也需要A的资源
def thread_A():
    global resource_B
    # 假设resource_B是线程B的锁
    if not resource_B.locked():  # B未锁定资源
        resource_B.acquire()  # A获得资源
        print("Thread A acquired resource B")

# 线程A释放资源，给线程B机会
        resource_B.release()
        print("Thread A released resource B")
    else:  # B已锁定资源
        print("Resource B is already locked by Thread B, waiting...")

def thread_B():
    global resource_A
    # 假设resource_A是线程A的锁
    if not resource_A.locked():  # A未锁定资源
        resource_A.acquire()  # B获得资源
        print("Thread B acquired resource A")

# 线程B释放资源，给线程A机会
        resource_A.release()
        print("Thread B released resource A")
    else:  # A已锁定资源
        print("Resource A is already locked by Thread A, waiting...")

# 创建两个线程
thread_A = threading.Thread(target=thread_A))
thread_B = threading.Thread(target=thread_B))

# 启动线程
thread_A.start()
thread_B.start()

# 等待所有线程完成
thread_A.join()
thread_B.join()
```

2. **优先级反转**：Python的` threads `模块默认是按照线程创建的时间顺序执行的。如果主线程优先级高于子线程，但子线程先启动，可能会出现优先级反转的情况。

```python
import threading

# 主线程，优先级高于子线程
def main():
    print("Main thread started with higher priority")
    time.sleep(2)  # 暂停主线程，让子线程有机会执行
    print("Main thread completed")

# 子线程，优先级低于主线程
def sub_thread():
    print("Subthread started with lower priority")
    time.sleep(3)  # 相比主线程更长的暂停时间

if __name__ == "__main__":
    main_thread = threading.Thread(target=main))
    sub_thread = threading.Thread(target=sub_thread))

# 启动子线程，给主线程一个机会
    sub_thread.start()

# 主线程等待所有子线程完成
    main_thread.join()
```

以上示例中，你可以根据需要调整优先级和执行顺序。