Was ist WebSocket?

WebSocket ist ein Protokoll, das eine bidirektionale Echtzeitkommunikation zwischen einem Browser und einem Server ermöglicht. Bei der herkömmlichen HTTP-Kommunikation sendet der Client eine Anfrage und der Server antwortet, um Daten auszutauschen. Im Gegensatz dazu können bei WebSocket sowohl der Client als auch der Server, sobald die erste Verbindung hergestellt ist, gegenseitig Nachrichten senden und empfangen, ohne dass wiederholt neue Verbindungen hergestellt werden müssen.

In letzter Zeit sind interaktive Dienste wie die OpenAI Realtime API und Hume AI häufiger geworden, was zu einem erwarteten Anstieg der Nachfrage nach WebSocket führt. Dieser Artikel stellt die Grundlagen der Verwendung von WebSocket vor und gibt einen Einblick in die damit verbundene asynchrone Verarbeitung.

Verwenden von WebSocket mit Python

In Python können Sie WebSocket wie unten gezeigt verwenden:

import asyncio
import websockets

uri = "ws://..."

async def hello():
    async with websockets.connect(uri) as websocket:
        await websocket.send("Hello, Server!")
        response = await websocket.recv()
        print(f"Server says: {response}")

asyncio.run(hello())

1. Stellen Sie mit websockets.connect(uri) eine Verbindung zum WebSocket-Server her.
2. Senden Sie eine Nachricht mit websocket.send(message).
3. Empfangen Sie eine Nachricht mit websocket.recv().

Asynchrone Verarbeitung

Die im vorherigen Code verwendeten Async- und Wait-Funktionen repräsentieren die asynchrone Verarbeitung. Die asynchrone Verarbeitung ist besonders effektiv, wenn mehrere Aufgaben gleichzeitig ausgeführt werden.

import asyncio

async def task1():
    print("Task 1: Start")
    await asyncio.sleep(2)  # Wait for 2 seconds
    print("Task 1: End")

async def task2():
    print("Task 2: Start")
    await asyncio.sleep(1)  # Wait for 1 second
    print("Task 2: End")

async def main():
    await asyncio.gather(task1(), task2())

asyncio.run(main())

In Funktionen, die „await“ verwenden, können andere Aufgaben ausgeführt werden, während auf den Abschluss der aktuellen Aufgabe gewartet wird. Dies ermöglicht einen effizienten Wechsel zwischen Aufgaben.

Asynchrone Verarbeitung und Multithreading

Multithreading übernimmt auch mehrere Aufgaben, es gibt jedoch einen Unterschied in der Art und Weise, wie Threads verwendet werden:

• Beim Multithreading hat jede Aufgabe ihren eigenen Thread und das Programm wechselt zwischen Aufgaben, während es auf den Abschluss bestimmter Prozesse wartet.
• Asynchrone Verarbeitung hingegen erstellt keine neuen Threads, sondern wechselt zwischen Aufgaben.

Multithreading ist effektiv, wenn mit CPU-intensiven oder blockierenden Vorgängen gearbeitet wird. Es hat jedoch Nachteile wie Overhead durch Threadwechsel (Kontextwechsel) und erhöhten Speicherverbrauch.

Im Gegensatz dazu reduziert die asynchrone Verarbeitung den Overhead durch den Kontextwechsel, da sie nicht auf Threads angewiesen ist. Wenn jedoch eine schwere Aufgabe ausgeführt wird, müssen möglicherweise andere Aufgaben warten. Daher eignet es sich für IO-gebundene Vorgänge wie API-Anfragen.

(Für Aufgaben, die rechenintensiv sind oder ein präzises Timing erfordern, ist Multiprocessing oft effektiver. Im Gegensatz zu Multithreading ermöglicht Multiprocessing die gleichzeitige Ausführung mehrerer Aufgaben.)

Wenn Sie beispielsweise die OpenAI Realtime API verwenden, um Audio von einem Mikrofon in Echtzeit zu empfangen und die Audiodaten an die API zu senden, können Sie eine Kombination aus Multithreading und asynchroner Verarbeitung verwenden:

import asyncio
import threading
import queue
import pyaudio
import websockets

# Use a queue to share data between threads
audio_queue = queue.Queue()

# Thread to capture audio using PyAudio
def audio_stream():
    p = pyaudio.PyAudio()
    stream = p.open(format=pyaudio.paInt16,
                    channels=1,
                    rate=44100,
                    input=True,
                    frames_per_buffer=1024)

    print("Start recording...")
    while True:
        data = stream.read(1024)
        audio_queue.put(data)

# Asynchronous function to send audio data via WebSocket
async def send_audio():
    uri = "ws://localhost:8765"
    async with websockets.connect(uri) as websocket:
        while True:
            # Get audio data from the queue
            data = audio_queue.get()
            if data is None:
                break
            await websocket.send(data)
            print("Sent audio data")

# Start the audio capture thread and run the asynchronous task
def main():
    audio_thread = threading.Thread(target=audio_stream)
    audio_thread.start()

    # Run the WebSocket sending task
    asyncio.run(send_audio())

if __name__ == "__main__":
    main()

Der Audioaufnahmeprozess ist ein blockierender Vorgang und wird daher mithilfe von Threading in einem separaten Thread ausgeführt. Im Gegensatz dazu erfolgt das Senden der Audiodaten, das IO-gebundene Vorgänge wie die Interaktion mit einer API umfasst, mithilfe asynchroner Verarbeitung. (Hinweis: PyAudio kann auch nicht blockierend mithilfe von Rückrufen ausgeführt werden.)

Abschluss

In diesem Artikel haben wir WebSocket und die asynchrone Verarbeitung vorgestellt.

Ich fand diese Konzepte bei der Arbeit mit der OpenAI Realtime API besonders verwirrend, daher habe ich dies als persönliche Anmerkung zusammengestellt. Wenn Sie Fehler finden oder Feedback haben, würde ich mich über Ihren Beitrag freuen.

Vielen Dank fürs Lesen bis zum Ende.