并发问题：Python多线程编程中的锁机制实例？

原创雨点打透心脏的1/2处 2025-02-17 01:21 0阅读 0赞

在Python的多线程编程中，锁机制是一种常见的同步工具，用于控制对共享资源的访问。下面是一个简单的锁机制实例：

```python
import threading

# 定义一个共享资源（可以是变量、列表等）
resource = 0

# 定义一个锁类
class Lock:
    def __init__(self):
        self.locked = False

def acquire(self):
        if not self.locked:
            self.locked = True
        else:
            raise threading.LockError("Lock is already held")

def release(self):
        if self.locked:
            self.locked = False
        else:
            raise threading.LockError("Lock is not held")

# 定义多线程类，使用锁进行同步控制
class threads_with_lock(threading.Thread):
    def __init__(self, name, lock):
        super().__init__(name=name)
        self.lock = lock

# 线程运行逻辑
    def run(self):
        print(f"Thread {self.name} acquired lock..."))
        self.lock.acquire()
        try:
            # 这里是你的线程任务代码，可以访问共享资源
            resource += 1
            print(f"Thread {self.name} incremented resource by 1..."))
        finally:
            # 确保锁已释放
            print(f"Thread {self.name} released lock..."))
            self.lock.release()

# 创建线程实例并锁
lock = Lock()
threads = [threads_with_lock(name=f'thread_{i+1}}', lock=lock) for i in range(5)]

# 启动所有线程
for thread in threads:
    thread.start()

# 等待所有线程结束
for thread in threads:
    thread.join()
```

这个例子中，我们创建了5个线程（每个线程名都是`thread_{i+1}}`），并且为共享资源加锁。每个线程运行时都会尝试获取锁，并在任务完成后释放锁。这样可以确保在同一时间只有一个线程能够访问共享资源。