Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-sonnet-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

from loguru import logger import asyncio class EventBus: def init(self):…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-opus-4-20250514’s answer.
  1. User

    from loguru import logger import asyncio

    class EventBus: def init(self): self._subscribers = {}

    def subscribe(self, event_type, callback):
        if event_type not in self._subscribers:
            self._subscribers[event_type] = []
        self._subscribers[event_type].append(callback)
    
    def unsubscribe(self, event_type, callback):
        if event_type in self._subscribers:
            try:
                self._subscribers[event_type].remove(callback)
            except ValueError:
                logger.warning(f"Callback not subscribed for event {event_type}")
    
    async def publish(self, event_type, *args, **kwargs):
        if event_type in self._subscribers:
            for callback in self._subscribers[event_type]:
                await callback(event_type, *args, **kwargs)
    

    class Subscriber: def init(self, name): self.name = name

    async def handle_event(self, event_type, data):
        logger.info(f"Subscriber {self.name} received event '{event_type}' with data: {data}")
    
        match event_type:
            case "power_on":
                logger.info("Handling 'power_on' event.")
            case "power_off":
                logger.info("Handling 'power_off' event.")
            case "power_restart":
                logger.info("Handling 'power_restart' event.")
                await ping_host(data)
            case _:
                logger.warning(f"Unknown event type: {event_type}")
    

    async def main(): from network import ping_host # 假设这是异步实现的

    event_bus = EventBus()
    subscriber1 = Subscriber("Subscriber1")
    subscriber2 = Subscriber("Subscriber2")
    
    event_bus.subscribe("power_restart", subscriber1.handle_event)
    event_bus.subscribe("power_restart", subscriber2.handle_event)
    
    await event_bus.publish("power_restart", "www.baidu.com")
    

    if name == 'main': asyncio.run(main()) 每个Subscriber并行执行pinghost

  2. Claude Assistant

    你的代码中,虽然每个 Subscriber 都会调用 ping_host,但它们是串行执行的,因为在 EventBus.publish 方法中使用了 await 来等待每个回调完成。要让每个 Subscriber 并行执行 ping_host,你需要修改 publish 方法。

    这里有几种实现方式:

    方法1:使用 asyncio.gather

    async def publish(self, event_type, *args, **kwargs):
        if event_type in self._subscribers:
            tasks = [callback(event_type, *args, **kwargs) for callback in self._subscribers[event_type]]
            await asyncio.gather(*tasks)
    

    方法2:使用 asyncio.create_task

    async def publish(self, event_type, *args, **kwargs):
        if event_type in self._subscribers:
            tasks = []
            for callback in self._subscribers[event_type]:
                task = asyncio.create_task(callback(event_type, *args, **kwargs))
                tasks.append(task)
            await asyncio.gather(*tasks)
    

    方法3:如果你不需要等待所有任务完成

    async def publish(self, event_type, *args, **kwargs):
        if event_type in self._subscribers:
            for callback in self._subscribers[event_type]:
                asyncio.create_task(callback(event_type, *args, **kwargs))
    

    完整的修改后代码示例:

    from loguru import logger
    import asyncio
    
    class EventBus:
        def __init__(self):
            self._subscribers = {}
    
        def subscribe(self, event_type, callback):
            if event_type not in self._subscribers:
                self._subscribers[event_type] = []
            self._subscribers[event_type].append(callback)
    
        def unsubscribe(self, event_type, callback):
            if event_type in self._subscribers:
                try:
                    self._subscribers[event_type].remove(callback)
                except ValueError:
                    logger.warning(f"Callback not subscribed for event {event_type}")
    
        async def publish(self, event_type, *args, **kwargs):
            if event_type in self._subscribers:
                # 并行执行所有回调
                tasks = [callback(event_type, *args, **kwargs) for callback in self._subscribers[event_type]]
                await asyncio.gather(*tasks)
    
    class Subscriber:
        def __init__(self, name):
            self.name = name
    
        async def handle_event(self, event_type, data):
            logger.info(f"Subscriber {self.name} received event '{event_type}' with data: {data}")
    
            match event_type:
                case "power_on":
                    logger.info("Handling 'power_on' event.")
                case "power_off":
                    logger.info("Handling 'power_off' event.")
                case "power_restart":
                    logger.info("Handling 'power_restart' event.")
                    await ping_host(data)  # 这里会并行执行
                case _:
                    logger.warning(f"Unknown event type: {event_type}")
    
    async def ping_host(host):
        # 模拟网络延迟
        logger.info(f"Starting ping to {host}")
        await asyncio.sleep(2)  # 模拟ping操作
        logger.info(f"Ping to {host} completed")
    
    async def main():
        event_bus = EventBus()
        subscriber1 = Subscriber("Subscriber1")
        subscriber2 = Subscriber("Subscriber2")
        
        event_bus.subscribe("power_restart", subscriber1.handle_event)
        event_bus.subscribe("power_restart", subscriber2.handle_event)
        
        logger.info("Publishing power_restart event...")
        await event_bus.publish("power_restart", "www.baidu.com")
        logger.info("All subscribers finished processing")
    
    if __name__ == '__main__':
        asyncio.run(main())
    

    使用 asyncio.gather 的好处是:

    • 所有任务并行执行
    • 等待所有任务完成后才继续
    • 如果任何一个任务抛出异常,会传播异常

    这样修改后,两个 Subscriber 会同时开始执行 ping_host,而不是等待第一个完成后再执行第二个。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.