python多线程通信方式

锁机制

1. Lock() 同步锁（互斥锁）

构造方法:

lock = threading.Lock()

方法:

• acquire(block=True, timeout=None): 获取锁，可选参数block为True时，如果锁被占用则阻塞等待；timeout为等待的最大时间。
• release(): 释放锁。

2. RLock() 递归锁

构造方法:

rlock = threading.RLock()

方法:

• acquire(block=True): 获取锁，可被同一个线程多次获取。
• release(): 释放锁，必须与acquire()调用次数匹配。

3. Condition() 条件锁

构造方法:

condition = threading.Condition()

方法:

• acquire(): 上锁。
• release(): 解锁。
• wait(timeout=None): 使线程等待直到被唤醒或超时。
• notify(n=1): 唤醒等待中的一个线程。
• notify_all(): 唤醒所有等待中的线程。

4. Event() 事件锁

构造方法:

event = threading.Event()

方法:

• set(): 设置事件状态为True。
• clear(): 清除事件状态，将其设置为False。
• is_set(): 判断锁状态
• wait(timeout=None): 阻塞线程直到事件状态为True。

5. Semaphore() 信号量锁

构造方法:

semaphore = threading.Semaphore(value)

方法:

• acquire(block=True, timeout=None): 获取信号量，如果信号量等于0，则阻塞线程，知道信号量大于0时唤醒，将计数减1并恢复线程
• release(): 释放信号量，信号量计数加1，使阻塞的线程有机会唤醒。

信号量代表的就是资源的数量，最低只能为0

---

Queue(队列)

Queue(maxsize=0)

• 创建队列: 初始化一个新的队列实例，maxsize参数定义队列的最大长度。如果未设置或设置为0，队列长度无限制。

put(item, block=True, timeout=None)

• 添加任务到队列: 将一个元素放入队列中。如果可选的block参数为True（默认值），在队列满时，操作将阻塞，直到有空位。timeout参数指定阻塞的最长时间。

get(block=True, timeout=None)

• 从队列中获取任务: 从队列中移除并返回一个元素。如果队列为空，block参数为True时，操作将阻塞，直到有元素可用。timeout参数同样适用于此情况。

task_done()

• 标记任务完成: 当一个任务被处理完毕后，调用此方法。这通常在工作线程中使用，以通知队列任务已完成。

join()

• 等待所有任务完成: 主线程调用此方法以阻塞，直到队列中的所有任务都被标记为完成。
• 如果不在主线程调用此方法，可能会导致队列中的任务丢失

示例

from queue import Queue
import threading
import time
import random
# 定义一个简单的生产者类
class Producer(threading.Thread):
    def __init__(self, task_queue):
        threading.Thread.__init__(self)
        self.task_queue = task_queue
        
    def run(self):
        for _ in range(3):
            item = random.randint(0, 100)  # 生产一个随机数作为产品
            self.task_queue.put(item)  # 将产品放入队列
            print(f"生产者 {self.name} 生产了产品: {item}")
            time.sleep(random.random())  # 随机等待一段时间  
        print(f"生产者 {self.name} 已停止。")



# 定义一个简单的消费者类
class Consumer(threading.Thread):
    def __init__(self, task_queue:Queue):
        threading.Thread.__init__(self)
        self.task_queue = task_queue

    def run(self):
        for _ in range(3):
            item = self.task_queue.get()  # 从队列中取出产品
            print(f"消费者 {self.name} 消费了产品: {item}")

            time.sleep(random.random())  # 随机等待一段时间处理产品
            self.task_queue.task_done() #标记任务完成
        print(f"消费者 {self.name} 已停止。")

# 创建队列和线程
task_queue = Queue(maxsize=3)

if __name__=="__main__":
    producer_list=[]
    for i in range(3):
        producer = Producer(task_queue)
        producer.start()
        producer_list.append(producer)
    consumer_list=[]
    for i in range(2):
        consumer = Consumer(task_queue)
        consumer.start()
        consumer_list.append(consumer)
    # task_queue.join()
    print("主线程执行")
    

通过对比是否有join的情况，可以发现使用join时，主线程会被阻塞，因为我们生产的产品大于消费的产品，导致队列中有产品未被处理，不满足join恢复的条件，而不使用join时，只要子线程结束，主线程也就结束了。所以会导致任务的丢失

LifoQueue(先进后出队列)

实际上就是栈，使用方法与queue一致

PriorityQueue(优先队列)

from queue import PriorityQueue

pq=PriorityQueue(maxsize=10)
pq.put((0,'a'))
pq.put((5,'b'))
pq.put((1,'c'))
pq.put((2,'d'))
pq.put((-5,'e'))

print(pq.get())
print(pq.get())
print(pq.get())
print(pq.get())
print(pq.get())

其他操作没什么区别，在put时给一个优先级
在get时会按照优先级数字从低到高取出

---

2024/3/24 笔记