Python并发编程：锁竞争和死锁问题示例

原创小灰灰 2025-02-11 14:33 20阅读 0赞

在Python中，多线程可能会遇到锁竞争（Race Conditions）和死锁等问题。这里我们将通过两个简单的示例来解释这些问题。

**1. 锁竞争示例**

假设我们有两个线程A和B，它们共享一个计数器`counter`，且对它进行加1操作。

```python
import threading

# 共享资源
counter = 0
lock = threading.Lock()

def thread_a():
    global counter, lock
    with lock:
        counter += 1
        print(f"A incremented counter: {counter}")

def thread_b():
    global counter, lock
    with lock:
        counter += 2
        print(f"B incremented counter: {counter}")

# 创建线程
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()
```

在这个示例中，线程A和B共享同一个计数器，并且它们都试图对计数器进行加1操作。由于`counter`是线程共享的资源，所以两个线程可能会同时执行对`counter`的加1操作。

**2. 死锁问题示例**

死锁是指在多进程通信（IPC）中，两个或更多的进程在执行过程中因争夺资源而造成的一种僵局状态。

下面是一个简单的Python多线程死锁例子：

```python
import threading

# 线程1需要线程2的锁A
lock_a = threading.Lock()
# 线程2需要线程1的锁B
lock_b = threading.Lock()

def thread1():
    global lock_a, lock_b
    with lock_a:
        print("Thread 1 locked A")
        # 假设这里有一个长时间的等待操作
        time.sleep(5)
        with lock_b:
            print("Thread 1 unlocked B and locked A again")

def thread2():
    global lock_a, lock_b
    with lock_b:
        print("Thread 2 locked B")
        with lock_a:
            print("Thread 2 unlocked A and locked B again")

# 创建线程
thread1 = threading.Thread(target=thread1))
thread2 = threading.Thread(target=thread2))

# 启动线程
thread1.start()
thread2.start()

# 等待所有线程完成
thread1.join()
thread2.join()
```

在这个例子中，线程1和线程2都试图获取对方的锁（`lock_a` 和 `lock_b`），从而形成了一个死锁。在实际情况中，要避免这种死锁问题，需要遵循适当的并发控制策略。