Python并发编程：锁和死锁问题实例

原创 Love The Way You Lie 2025-01-05 10:45 40阅读 0赞

在Python的并发编程中，锁是一种同步原语，用于控制对共享资源的访问。而死锁则是多个进程或线程互相等待对方释放资源的情况。

以下是一些实例：

1. 锁的使用
```python
import threading

# 定义一个共享资源
resource = 0

# 定义两个锁
lock1 = threading.Lock()
lock2 = threading.Lock()

def process1():
    global resource
    lock1.acquire()  # 进入保护块
    try:
        resource += 1
        print(f"Process 1: Resource {resource} acquired.")
    finally:
        lock1.release()  # 释放锁

def process2():
    global resource
    lock2.acquire()  # 进入保护块
    try:
        resource -= 1
        if resource < 0:
            print("Resource has negative value, error occurred.")
            return
        print(f"Process 2: Resource {resource} acquired by acquiring lock {lock2.lock_name}).")
    finally:
        lock2.release()  # 释放锁

# 创建线程并执行
thread1 = threading.Thread(target=process1))
thread2 = threading.Thread(target=process2))

thread1.start()
thread2.start()

thread1.join()
thread2.join()
```
在这个例子中，`process1`和`process2`是两个独立的进程。它们通过锁（`lock1`和`lock2`）来控制对资源的操作。

2. 死锁问题
```python
import threading

# 定义一个共享资源
resource = 0

# 定义两个线程，它们互锁并尝试获取资源
thread1 = threading.Thread(target=acquire_resource_1))
thread2 = threading.Thread(target=acquire_resource_2))

thread1.start()
thread2.start()

# 确保所有线程完成后再结束程序
thread1.join()
thread2.join()

def acquire_resource_1():
    global resource
    lock.acquire()  # 进入保护块
    try:
        resource += 1
        print(f"Thread 1: Resource {resource} acquired by acquiring lock {lock.lock_name}).")
    finally:
        lock.release()  # 释放锁

def acquire_resource_2():
    global resource
    lock.acquire()  # 进入保护块
    try:
        resource -= 1
        if resource < 0:
            print("Resource has negative value, error occurred.")
            return
        print(f"Thread 2: Resource {resource} acquired by acquiring lock {lock.lock_name})."))
    finally:
        lock.release()  # 释放锁

# 定义锁和创建线程
lock = threading.Lock()
thread1.start()
thread2.start()

```
在这个例子中，`acquire_resource_1`和`acquire_resource_2`是两个互斥的资源获取者。它们都试图通过锁（`lock`）来保护对共享资源的操作。

如果两个线程按照`thread1 -> acquire_resource_1 -> lock -> thread2 -> acquire_resource_2 -> lock`这样的顺序执行，那么会出现死锁。因为两个线程都在等待对方释放锁。