并发编程：Python中常见线程和锁问题案例

原创 Dear 丶 2025-01-10 10:51 38阅读 0赞

在Python中，实现并发有两种主要方式：使用内置的`threading`模块创建线程，以及利用锁（`Lock`、`RLock`等）来控制共享资源。

下面是一些常见线程和锁问题的案例：

1. 线程安全的类
   例：
   ```python
   class Counter:
       def __init__(self):
           self.count = 0

@threading.Lock()
       def increment(self):
           self.count += 1
           return self.count
   ```
   在这个例子中，我们使用锁来确保在任何时候只有一个线程可以访问`increment`方法。

2. 锁死问题
   例：
   ```python
   class ExpensiveCalculator:
       def __init__(self):
           self.cache = {}

@threading.Lock()
       def calculate_expensive(self, num):
           if num in self.cache:
               return self.cache[num]
           result = num ** 3  # 假设计算过程非常昂贵
           self.cache[num] = result
           return result

calc = ExpensiveCalculator()
   t1 = threading.Thread(target=calc.calculate_expensive, args=(1,), lock=calc.lock))
   t2 = threading.Thread(target=calc.calculate_expensive, args=(2,), lock=calc.lock))

t1.start()
   t2.start()

# 这里可能会导致锁死，因为两个线程都在尝试获取同一个锁
   calc.calculate_expensive(3, lock=calc.lock))
   ```
   在这个例子中，我们创建了一个`ExpensiveCalculator`类，其中的计算过程非常昂贵。然后两个线程试图同时计算一个特定数字。

由于在获取锁的同时进行计算，这可能导致锁死问题。为了避免这种情况，需要确保每次只有一条线程能够获得并使用锁。