Python多线程通信问题：锁、信号量和队列使用示例

原创 ╰半橙微兮° 2025-03-15 23:57 39阅读 0赞

在Python中，我们可以通过内置的`threading`模块来实现多线程。这里分别介绍锁（Lock）、信号量（Semaphore）和队列（Queue）的使用示例：

1. 锁（Lock）
   进行资源访问时，可以使用锁防止多个线程同时访问同一资源。

```python
import threading

# 示例资源
resource = "shared resource"

# 定义锁
lock = threading.Lock()

def worker(lock, resource):
    with lock:
        # 独占资源进行操作
        print(f"Worker {threading.current_thread().name} acquired lock and accessed {resource}")

# 创建两个工作线程
thread1 = threading.Thread(target=worker, args=(lock, resource), name="Thread 1"))
thread2 = threading.Thread(target=worker, args=(lock, resource), name="Thread 2"))

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

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

2. 信号量（Semaphore）
   当多个线程需要共享有限的资源时，可以使用信号量来协调。

```python
import threading

# 示例资源数量
resource_count = 5

# 定义信号量
semaphore = threading.Semaphore(resource_count)

def worker(semaphore, resource_count):
    with semaphore:
        # 获取资源进行操作
        if resource_count > 0:
            print(f"Worker {threading.current_thread().name} acquired semaphore and accessed resource")
            resource_count -= 1
        else:
            print("Worker reached the end of resources")

# 创建两个工作线程
thread1 = threading.Thread(target=worker, args=(semaphore, resource_count), name="Thread 1"))
thread2 = threading.Thread(target=worker, args=(semaphore, resource_count), name="Thread 2"))

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

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

3. 队列（Queue）
   在多线程环境下，队列常用于任务调度和消息传递。

```python
import queue

class Worker(threading.Thread):
    def __init__(self, q):
        threading.Thread.__init__(self)
        self.q = q

def run(self):
        while True:
            task = self.q.get()
            if task is None:  # 信号停止接收任务
                break
            # 执行任务
            print(f"Worker {threading.current_thread().name}} started task: {task}")
            self.q.task_done()

def producer(q):
    tasks = ["Task 1", "Task 2", "Task 3"]
    for task in tasks:
        q.put(task)
    q.put(None)  # 信号停止接收任务

if __name__ == "__main__":
    q = queue.Queue()

# 创建生产者线程
    producer_thread = Worker(q)
    producer_thread.start()

print("Producer started. Waiting for tasks to complete.")

# 创建消费者线程
    worker_thread = threading.Thread(target=Worker.run, args=(q,), name="Consumer"))
    worker_thread.start()

# 等待所有任务完成和信号停止接收任务
    q.join()

print("All tasks completed. Producer and Consumer threads terminated.")
```

以上示例展示了如何使用锁（Lock）、信号量（Semaphore）和队列（Queue）来实现多线程通信。