多线程同步问题：Python threading中的锁和队列操作示例

原创蔚落 2024-12-18 02:15 0阅读 0赞

在Python的threading模块中，提供了多种同步机制来控制多线程之间的交互。这里主要介绍两种方式：锁（Lock）和队列（Queue）。

1. 锁（Lock）
```python
from threading import Lock

# 创建一个锁对象
lock = Lock()

# 使用锁进行互斥操作
def thread_function(lock):
    with lock:
        print(f"Thread {thread_name} acquired lock.")
        # 这里是需要同步执行的代码
        time.sleep(2)
        print(f"Thread {thread_name} released lock.")

# 创建两个线程，每个线程获取锁并执行任务
thread1_name = "Thread 1"
thread2_name = "Thread 2"

t1 = threading.Thread(target=thread_function, args=(lock, thread1_name))))
t2 = threading.Thread(target=thread_function, args=(lock, thread2_name))))

t1.start()
t2.start()

# 等待两个线程执行完毕
t1.join()
t2.join()
```

2. 队列（Queue）
```python
from threading import Thread, Queue

class WorkerThread(Thread):
    def __init__(self, queue):
        super().__init__()
        self.queue = queue

def run(self):
        while True:
            task = self.queue.get()
            if task is None:
                # 任务完成，队列中放入None
                break
            print(f"Worker thread processing task: {task}")
            self.queue.task_done()

def producer(q):
    tasks = ['Task 1', 'Task 2', 'Task 3']
    for task in tasks:
        q.put(task)
        # 随机睡眠一段时间，模拟生产过程中的等待
        import random
        time.sleep(random.uniform(0, 2)) )

if __name__ == "__main__":
    queue = Queue()
    producer_thread = WorkerThread(queue)

producer_thread.start()

# 向队列中放入None，表示任务已完成
    queue.put(None)

producer_thread.join()
```

通过以上示例，你可以看到如何使用锁来控制线程的互斥访问，以及如何利用队列进行多线程协作。