Python并发编程：锁与死锁案例分析

原创川长思鸟来 2025-03-11 21:45 66阅读 0赞

在Python中，线程同步主要通过` Lock ` 和 ` RLock `（读写锁）来实现。下面我们将通过一些案例分析这两种锁的使用和可能出现的问题。

1. **基本使用示例**：
```python
from threading import Thread, Lock

lock = Lock()

def threadfunc(name, lock):
    print(f"Thread {name} started with lock {lock}")
    lock.acquire()
    try:
        # critical section
        print(f"Thread {name} executing critical section")
    finally:
        lock.release()
        print(f"Thread {name} released lock {lock}")

threads = [
    Thread(target=threadfunc, args=("thread1", lock)), daemon=True,
    Thread(target=threadfunc, args=("thread2", lock)), daemon=True,
]

# 启动所有线程
for thread in threads:
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()
```

2. **死锁案例分析**：
- **例子一：多个读写锁的死锁**：
```python
from threading import Lock, RLock

lock1 = Lock()
lock2 = RLock()

def read_writeThread(lock):
    print(f"Thread started with lock {lock}")
    # Critical section: Read (no lock needed) and write (with RLock)
    try:
        # Read
        print("Reading from the resource using lock {lock}...")
        
        # Write (with RLock to serialize access))
        print("Writing to the resource using RLock {lock}...")
    finally:
        print(f"Thread released lock {lock}}")

threads = [
    Thread(target=read_writeThread, args=(lock1,),)), 
    Thread(target=read_writeThread, args=(lock2,),)), 
]

# 启动所有线程
for thread in threads:
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()
```
- **例子二：互斥锁与读写锁的死锁**：
```python
from threading import Lock, RLock

lock1 = Lock()
lock2 = RLock()

def writeThread(lock):
    print(f"Thread started with lock {lock}")
    
    # Critical section: Write (with RLock to serialize access))
    try:
        print("Writing to the resource using RLock {lock}...")
        
        # This write would block if lock2 is held by another thread
        lock.acquire()
        lock.release()
    finally:
        print(f"Thread released lock {lock}}")

threads = [
    Thread(target=writeThread, args=(lock1,),)), 
    Thread(target=writeThread, args=(lock2,),)), 
]

# 启动所有线程
for thread in threads:
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()
```
在上述例子中，死锁通常由于多个线程相互等待对方释放资源而产生。通过合理设置锁的权限和使用顺序，可以避免这类问题。