Python浅谈一下线程间通信之队列

在Python多线程编程中，线程间通信是一个非常重要的概念，通过线程间通信可以实现数据共享、协同工作等功能。队列是线程间通信的常用方式之一。

队列的作用

队列是一种数据结构，用于在多线程编程中传递信息。队列提供了一个先进先出（FIFO）的缓冲区，允许一个线程写数据，一个线程读数据。

Python队列的实现

Python标准库中提供了Queue模块用来实现线程间通信。Queue模块提供了多种队列实现方式，可以选择适合自己的队列。

队列的种类

1. 先进先出队列（queue.Queue）：此队列与列表类似，但适用于线程和进程编程。
2. 双端队列（collections.deque）： deque是一个双端队列，可快速的在队列两端进行操作，也可作为 栈使用。
3. 优先队列（queue.PriorityQueue）：按照元素的优先级弹出。

线程间使用队列通信

在Python多线程编程中，队列常用来实现线程间通信，可以通过队列实现多个线程之间的数据传递。生产者线程向队列中添加数据，消费者线程从队列中获取数据处理。

以下是使用队列实现线程间通信的示例：

import threading
import queue
import time

class Producer(threading.Thread):

    def __init__(self, queue):
        threading.Thread.__init__(self)
        self.queue = queue

    def run(self):
        for i in range(5):
            print('生产者生产了数据：', i)
            self.queue.put(i)
            time.sleep(1)
        print('生产者生产完毕')

class Consumer(threading.Thread):

    def __init__(self, queue):
        threading.Thread.__init__(self)
        self.queue = queue

    def run(self):
        while True:
            if not self.queue.empty():
                data = self.queue.get()
                print('消费者处理了数据：', data)
                time.sleep(1)
            else:
                break
        print('消费者处理完毕')

def main():
    q = queue.Queue()
    producer = Producer(q)
    consumer = Consumer(q)
    producer.start()
    consumer.start()

if __name__ == '__main__':
    main()

这里创建了一个生产者线程和一个消费者线程，生产者向队列中添加数据，消费者从队列中获取数据处理。在生产者中使用put方法向队列中加入数据，在消费者中使用get方法从队列中获取数据。

线程池和信号量

线程池和信号量也是线程间通信的重要方式。线程池是指预先创建指定数量的线程，这些线程可以复用执行不同的任务。信号量用于对资源的访问控制。线程池和信号量的使用可以大大提高多线程编程的效率。

以下是使用线程池和信号量实现线程间通信的示例：

import threading
import time
import queue

class ThreadPool(object):

    def __init__(self, max_thread_num):
        self.queue = queue.Queue()
        self.max_thread_num = max_thread_num
        self.threads = []
        self.semaphore = threading.Semaphore(self.max_thread_num)

    def add_task(self, func, args=()):
        self.queue.put((func, args))

    def _run(self):
        while True:
            self.semaphore.acquire()
            if not self.queue.empty():
                task, args = self.queue.get()
                task(*args)
                time.sleep(1)
                self.semaphore.release()
            else:
                break

    def start(self):
        for i in range(self.max_thread_num):
            t = threading.Thread(target=self._run)
            self.threads.append(t)
            t.start()

def worker(num):
    print('线程%d开始执行任务' % num)
    time.sleep(3)
    print('线程%d完成任务' % num)

def main():
    pool = ThreadPool(3)
    for i in range(5):
        pool.add_task(worker, args=(i,))
    pool.start()

if __name__ == '__main__':
    main()

该示例使用线程池和信号量实现多个线程执行任务的过程。通过向线程池中添加任务，线程池会自动分配线程执行任务，从而避免了线程过多带来的线程上下文切换开销。同时，使用信号量可以控制可用线程的数量，避免线程过多导致系统负载过高的问题。

以上就是Python中使用队列实现线程间通信的方法和示例。队列是一个非常重要的线程间通信方式，对于多线程编程来说具有非常重要的意义。