Python并发编程困惑：死锁、竞态条件示例

原创ゞ浴缸里的玫瑰 2025-03-07 22:39 30阅读 0赞

在Python的并发编程中，经常会遇到一些可能会导致程序执行错误的问题。以下是两个主要问题的示例：

1. 死锁（Deadlock）：
   当两个或更多的进程因争夺资源而造成的一种相互等待的现象时，就会出现死锁。

示例代码：
   ```python
   import threading

# 资源1
   resource_1 = threading.Lock()

# 资源2
   resource_2 = threading.Lock()

def process_1():
       with resource_1:
           print("Process 1: Acquiring resource 1.")
           time.sleep(2)  # 模拟耗时操作

print("Process 1: Releasing resource 1.")

with resource_2:
           print("Process 1: Acquiring resource 2.")
           time.sleep(3)  # 模拟耗时操作

print("Process 1: Releasing resource 2.")

def process_2():
       with resource_2:
           print("Process 2: Acquiring resource 2.")
           time.sleep(4)  # 模拟耗时操作

print("Process 2: Releasing resource 2.")

with resource_1:
           print("Process 2: Acquiring resource 1.")
           time.sleep(5)  # 模拟耗时操作

print("Process 2: Releasing resource 1.")

thread_1 = threading.Thread(target=process_1))
   thread_2 = threading.Thread(target=process_2))

thread_1.start()
   thread_2.start()

# 此处会陷入死锁，因为两个进程都在等待对方释放资源
   thread_1.join()
   thread_2.join()
   ```

2. 竞态条件（Race Condition）：
   当多个线程共享资源并同时访问或修改这些资源时，可能会出现与预期结果不一致的现象。

示例代码：
   ```python
   import threading

counter = 0  # 共享的计数器

def increment_counter():
       nonlocal counter
       counter += 1
       print("Incremented counter: ", counter)

thread_1 = threading.Thread(target=increment_counter))
   thread_2 = threading.Thread(target=increment_counter))

thread_1.start()
   thread_2.start()

thread_1.join()
   thread_2.join()

# 结果可能为 3（因为线程 2 的计数器值加到 counter 上）或 5
   ```

以上示例展示了Python并发编程中的两种常见问题：死锁和竞态条件。

还没有评论，来说两句吧...