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

原创小灰灰 2025-01-22 04:42 4阅读 0赞

在Python的并发编程中，锁机制（Lock）是用于控制对共享资源访问的一种工具。以下是一个简单的锁机制实例：

```python
import threading

# 定义一个共享资源
shared_resource = 0

class LockingThread(threading.Thread):
    def __init__(self, name, resource=shared_resource):
        super(LockingThread, self).__init__(name)
        self.resource = resource

@staticmethod
    def acquire_lock(lock_obj):
        lock_obj.acquire()

@staticmethod
    def release_lock(lock_obj):
        lock_obj.release()

def run(self):
        # 在线程运行过程中，尝试获取锁
        try:
            LockingThread.acquire_lock(self)
            print(f"Thread {self.name} acquired the lock on resource {self.resource}.")
            # 模拟耗时操作
            time.sleep(2)
            print("Thread is executing the critical section.")
        except threading.LockError as e:
            print(f"Thread {self.name} failed to acquire the lock: {e}")
        finally:
            # 无论是否成功获取锁，都需要释放锁
            LockingThread.release_lock(self)

# 创建两个线程实例
thread1 = LockingThread("Thread-1", shared_resource)
thread2 = LockingThread("Thread-2", shared_resource)

# 启动线程
thread1.start()
thread2.start()

# 等待所有线程完成
thread1.join()
thread2.join()
```

这个例子中，`LockingThread`类代表一个具有锁机制的线程。每个线程在运行过程中尝试获取锁，然后执行耗时操作。最后，无论是否成功获取锁，都需要释放锁以确保其他线程可以访问资源。