在Python中模拟Go语言的Select通道操作

import threading
import queue # 在Python 3中，Queue模块被重命名为queue

def main_simulation_basic():
    # 模拟Go语言中的通道
    c1 = queue.Queue(maxsize=0)
    c2 = queue.Queue(maxsize=0)
    quit_channel = queue.Queue(maxsize=0) # 使用更具描述性的名称

    # 模拟Go语言中的Goroutine：生产者函数1
    def producer_func1():
        for i in range(10):
            c1.put(i)
        quit_channel.put(0) # 完成后发送退出信号

    # 启动生产者线程1
    threading.Thread(target=producer_func1).start()

    # 模拟Go语言中的Goroutine：生产者函数2
    def producer_func2():
        for i in range(2):
            c2.put(i)

    # 启动生产者线程2
    threading.Thread(target=producer_func2).start()

    # 创建一个中央队列，用于收集所有通道的消息
    combined_queue = queue.Queue(maxsize=0)

    # 辅助函数：监听一个队列并将消息转发到combined_queue
    def listen_and_forward(source_queue):
        while True:
            # 获取消息，并将其与源队列一起放入combined_queue
            # (source_queue, message) 这种元组结构用于标识消息来源
            message = source_queue.get()
            combined_queue.put((source_queue, message))
            # 注意：这里需要一个机制来优雅地停止这些转发线程，
            # 否则它们会一直运行。对于本例，我们依赖主线程退出时守护线程自动终止。

    # 为每个通道启动一个转发线程
    t_c1 = threading.Thread(target=listen_and_forward, args=(c1,))
    t_c1.daemon = True # 设置为守护线程，主线程退出时自动终止
    t_c1.start()

    t_c2 = threading.Thread(target=listen_and_forward, args=(c2,))
    t_c2.daemon = True
    t_c2.start()

    t_quit = threading.Thread(target=listen_and_forward, args=(quit_channel,))
    t_quit.daemon = True
    t_quit.start()

    # 主循环：从combined_queue中获取消息并处理
    while True:
        which_queue, message = combined_queue.get()
        if which_queue is c1:
            print(f'Received value from c1: {message}')
        elif which_queue is c2:
            print(f'Received value from c2: {message}')
        elif which_queue is quit_channel:
            print('Received quit signal. Exiting.')
            break # 收到退出信号，终止循环

# 调用主模拟函数
if __name__ == '__main__':
    main_simulation_basic()

import threading
import queue # 在Python 3中，Queue模块被重命名为queue

def select(*queues):
    """
    一个模拟Go语言select语句的Python生成器函数。
    它接受多个Queue对象，并持续yield出 (源队列, 消息) 元组。
    """
    combined_queue = queue.Queue(maxsize=0)

    def listen_and_forward(source_queue):
        while True:
            try:
                message = source_queue.get()
                combined_queue.put((source_queue, message))
            except Exception as e:
                # 实际应用中可能需要更复杂的错误处理或停止机制
                print(f"Error in listen_and_forward for {source_queue}: {e}")
                break

    # 为每个传入的队列启动一个守护转发线程
    for q in queues:
        t = threading.Thread(target=listen_and_forward, args=(q,))
        t.daemon = True
        t.start()

    # 主循环：持续从combined_queue中获取消息并yield
    while True:
        yield combined_queue.get()

def main_simulation_reusable():
    c1 = queue.Queue(maxsize=0)
    c2 = queue.Queue(maxsize=0)
    quit_channel = queue.Queue(maxsize=0)

    def producer_func1():
        for i in range(10):
            c1.put(i)
        quit_channel.put(0)

    threading.Thread(target=producer_func1).start()

    def producer_func2():
        for i in range(2):
            c2.put(i)

    threading.Thread(target=producer_func2).start()

    # 使用封装后的select函数
    for which_queue, msg in select(c1, c2, quit_channel):
        if which_queue is c1