如何同时处理多个websocket消息？

import tornado.ioloop
import tornado.web
import tornado.websocket

class WebSocketHandler(tornado.websocket.WebSocketHandler):
    def open(self):
        print("WebSocket opened")

    def on_message(self, message):
        print(f"Received message: {message}")
        self.write_message(f"Echo: {message}")

    def on_close(self):
        print("WebSocket closed")

def make_app():
    return tornado.web.Application([
        (r"/websocket", WebSocketHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

import asyncio

class WebSocketServer:
    def __init__(self, host='127.0.0.1', port=8888):
        self.host = host
        self.port = port
        self.clients = set()

    async def handle_client(self, reader, writer):
        ws = await asyncio.wait_for(self.handshake(reader, writer), timeout=10)
        if ws:
            self.clients.add(ws)
            try:
                await self.client_handler(ws)
            finally:
                self.clients.remove(ws)

    async def client_handler(self, ws):
        while True:
            message = await ws.recv()
            if message is None:
                break
            for client in self.clients:
                if client != ws:
                    await client.send(message)

    async def handshake(self, reader, writer):
        headers = {}
        while True:
            line = await reader.readline()
            if not line:
                break
            parts = line.decode().strip().split(': ')
            if len(parts) == 2:
                headers[parts[0]] = parts[1]
            if parts[0] == 'Sec-WebSocket-Key':
                key = parts[1]
                response_key = f'258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
                hashed = hashlib.sha1(f'{key}{response_key}'.encode()).digest()
                response = f'HTTP/1.1 101 Switching Protocols\r\n'
                response += f'Upgrade: websocket\r\n'
                response += f'Connection: Upgrade\r\n'
                response += f'Sec-WebSocket-Accept: {base64.b64encode(hashed).decode()}\r\n\r\n'
                writer.write(response.encode())
                await writer.drain()
                return WebSocketConnection(reader, writer)

    async def start(self):
        server = await asyncio.start_server(self.handle_client, self.host, self.port)
        async with server:
            await server.serve_forever()

class WebSocketConnection:
    def __init__(self, reader, writer):
        self.reader = reader
        self.writer = writer

    async def send(self, message):
        frame = self.create_frame(message)
        self.writer.write(frame)
        await self.writer.drain()

    def create_frame(self, message):
        # 创建WebSocket帧的逻辑
        pass

async def main():
    server = WebSocketServer()
    await server.start()

if __name__ == "__main__":
    asyncio.run(main())