并发编程中常见的锁问题实例

原创谁践踏了优雅 2024-10-21 04:33 23阅读 0赞

在并发编程中，锁是一种同步机制，用于控制对共享资源的访问。常见的锁问题包括死锁、活锁和优先级反转等。

以下是一个简单的死锁例子：

```python
# 定义两个进程需要使用的资源
resource1 = 'CPU1'
resource2 = 'CPU2'

# 定义每个进程需要的资源和已经获取的资源
process1_resources = [resource1]
process1_acquired = []

process2_resources = [resource2]
process2_acquired = []

# 检查是否发生死锁（两个进程互相等待对方释放资源）：
def check_deadlock():
    # 进程1尝试获取资源1，然后释放已获取的资源
    if resource1 in process1_resources and resource1 not in process1_acquired:
        process1_resources.append(resource1)
        process1_acquired.append(resource1)

# 确认资源2没有被进程2占用，否则进程1无法获得资源2
        if resource2 not in process2_resources:
            print(f"Process 1 successfully acquires {resource1} and {resource2}."))
        else:
            print(f"Resource {resource2}} is already acquired by Process 2. Deadlock occurred.")

# 进程2尝试获取资源2，然后释放已获取的资源
    elif resource2 in process2_resources and resource2 not in process2_acquired:
        process2_resources.append(resource2)
        process2_acquired.append(resource2)

# 确认资源1没有被进程1占用，否则进程2无法获得资源1
        if resource1 not in process1_resources:
            print(f"Process 2 successfully acquires {resource2} and {resource1}."))
        else:
            print(f"Resource {resource1}} is already acquired by Process 1. Deadlock occurred.")
    else:
        print("No resources are currently held by either process. No deadlock detected yet.")

# 调用检查死锁的函数
check_deadlock()
```

在这个例子中，如果两个进程按照以下顺序操作：

1. 进程1获取资源1。
2. 进程1获取资源2。
3. 进程2获取资源2。

那么就可能会发生死锁，因为两个进程都在等待对方释放资源。