Python并发编程：多线程、进程和锁的问题实例

原创悠悠 2025-01-01 21:54 109阅读 0赞

在Python中，我们经常使用多线程来实现并发。但是，多线程并非没有问题，主要涉及到以下几个方面：

1. **全局变量**：
   多线程可能会修改共享的全局变量，导致结果不正确。

```python
   count = 0
   def thread_func():
       nonlocal count
       count += 1
       print(f"Thread {thread_name} updated count to {count}")

threads = []
   for i in range(5):
       t = threading.Thread(target=thread_func, name=f"Thread-{i+1}")
       threads.append(t)
       t.start()
   ```
   
2. **锁（Lock）**：
   当多个线程访问共享资源时，为防止数据竞争，通常使用`Lock`对象来锁定资源。

```python
   import threading

counter = 0
   lock = threading.Lock()

def thread_func(index):
       nonlocal counter, lock
       with lock:
           counter += index
       print(f"Thread {thread_name} updated counter to {counter}")

threads = []
   for i in range(5):
       t = threading.Thread(target=thread_func, name=f"Thread-{i+1}}", args=(i,))
       threads.append(t)
       t.start()
   
   # 在所有线程完成之前，不要使用 `counter`
   ```
   
3. **死锁（Deadlock）**：
   如果两个或更多的线程互相等待对方释放资源，那么就可能导致死锁。

```python
   import threading

resource1 = threading.Lock()
   resource2 = threading.Lock()

def thread_func(i, j):
       with resource1:
           print(f"Thread {i} acquired resource 1")
           with resource2:
               print(f"Thread {i} acquired resource 2"))
       print(f"Thread {i} released resources"))

threads = []
   for i in range(3):
       t = threading.Thread(target=thread_func, args=(i, i)), name=f"Thread-{i+1}}")
       threads.append(t)
       t.start()
   
   # 这里没有实现资源释放，所以会导致死锁
   ```
   
解决这些问题的主要策略包括：合理设计并发程序，避免全局变量；使用`Lock`、`Semaphore`等同步原语；理解和避免死锁的发生。