Python多线程编程：同步锁和死锁问题实例

原创怼烎@ 2025-02-14 00:27 19阅读 0赞

在Python多线程编程中，同步锁（如`threading.Lock()`）用于控制对共享资源的访问。如果管理不当，可能会导致死锁问题。

下面是一些实例来说明同步锁和死锁问题：

1. **无锁互斥**：
   ```python
   import threading

lock = threading.Lock()

def thread_function():
       with lock:
           print("Thread 1 acquired lock")
           # 执行一些操作，比如写文件等
           print("Thread 1 released lock")

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

thread1.start()
   thread2.start()

thread1.join()
   thread2.join()
   ```
   这个例子中，`lock`是一个互斥锁（独占型锁），当一个线程获得了这个锁，其他线程必须等待锁被释放才能获得。

2. **死锁**：
   ```python
   import threading

lock1 = threading.Lock()
   lock2 = threading.Lock()

def thread_function1():
       with lock1:
           print("Thread 1 acquired lock1")
           # 等待锁2被获取
           with lock2:
               print("Thread 1 acquired lock2")
           print("Thread 1 released locks")

def thread_function2():
       with lock2:
           print("Thread 2 acquired lock2")
           # 等待锁1被获取
           with lock1:
               print("Thread 2 acquired lock1")
               print("Thread 2 released locks")

thread1 = threading.Thread(target=thread_function1))
   thread2 = threading.Thread(target=thread_function2))

thread1.start()
   thread2.start()

thread1.join()
   thread2.join()
   ```
   在这个例子中，`lock1`和`lock2`是两个互斥锁。当线程1获得了`lock1`后，它必须等待`lock2`被获取。而当线程2获得了`lock2`后，它也需要等待`lock1`被获取。

如果线程1和线程2的执行顺序不满足这个条件（比如：线程2先获取了`lock2`），就可能会导致死锁问题，即两个或多个线程互相等待对方释放资源，从而形成无法继续执行的状态。