Synchrone und asynchrone Programmierung in Python: Schlüsselkonzepte und Anwendungen

Synchronisierte Programmierung
Bei der synchronen Programmierung werden Aufgaben nacheinander ausgeführt. Jede Aufgabe muss abgeschlossen sein, bevor die nächste beginnt. Dieser lineare Ansatz ist unkompliziert, kann jedoch ineffizient sein, insbesondere wenn es um E/A-gebundene Vorgänge wie das Lesen von Dateien, Netzwerkanforderungen oder Datenbankabfragen geht.

import time

def task1():
    print("Starting task 1...")
    time.sleep(2)
    print("Task 1 completed")

def task2():
    print("Starting task 2...")
    time.sleep(2)
    print("Task 2 completed")

def main():
    task1()
    task2()

if __name__ == "__main__":
    main()

In diesem Beispiel muss Aufgabe1 abgeschlossen sein, bevor Aufgabe2 beginnt. Die Gesamtausführungszeit ist die Summe der Zeit, die jede Aufgabe benötigt.

Asynchrone Programmierung
Durch die asynchrone Programmierung können mehrere Aufgaben gleichzeitig ausgeführt werden, wodurch die Effizienz verbessert wird, insbesondere bei E/A-gebundenen Aufgaben. Die Asyncio-Bibliothek von Python stellt die notwendigen Werkzeuge für die asynchrone Programmierung bereit.

import asyncio

async def task1():
    print("Starting task 1...")
    await asyncio.sleep(2)
    print("Task 1 completed")

async def task2():
    print("Starting task 2...")
    await asyncio.sleep(2)
    print("Task 2 completed")

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

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

In diesem Beispiel werden Aufgabe 1 und Aufgabe 2 gleichzeitig ausgeführt, wodurch die Gesamtausführungszeit auf die Zeit reduziert wird, die die längste Aufgabe benötigt.

Mögliche Anwendungen

Webserver und APIs:

• Synchron: Herkömmliche Web-Frameworks wie Flask verarbeiten Anfragen nacheinander. Dies kann bei der Bearbeitung einer großen Anzahl von Anfragen zu einem Engpass führen.
• Asynchron: Frameworks wie FastAPI und aiohttp verwenden asynchrone Programmierung, um mehrere Anfragen gleichzeitig zu verarbeiten und so Durchsatz und Leistung zu verbessern.

Echtzeit-Messaging-Anwendungen:

• Synchron: Die Verarbeitung von Echtzeitnachrichten kann zu Verzögerungen führen, wenn jede Nachricht nacheinander verarbeitet wird.
• Asynchron: Die Verwendung von WebSockets mit asynchroner Verarbeitung (z. B. Websockets-Bibliothek) ermöglicht eine bidirektionale Kommunikation in Echtzeit und ermöglicht leistungsstarke Chat-Anwendungen, Live-Benachrichtigungen usw.

Datenverarbeitungspipelines:

• Synchron: Die sequentielle Verarbeitung großer Datensätze kann zeitaufwändig sein.
• Asynchron: Asynchrone Aufgaben können Daten gleichzeitig abrufen, verarbeiten und speichern, wodurch die Verarbeitungszeit erheblich verkürzt wird. Bibliotheken wie aiohttp und aiomysql können für asynchrone HTTP-Anfragen und Datenbankoperationen verwendet werden.

Web-Scraping:

• Synchron: Das sequentielle Abrufen von Webseiten kann langsam und ineffizient sein.
• Asynchron: Durch die Verwendung von aiohttp für asynchrone HTTP-Anfragen können mehrere Webseiten gleichzeitig abgerufen werden, wodurch der Web-Scraping-Prozess beschleunigt wird.

Datei-E/A-Vorgänge:

• Synchron: Das sequentielle Lesen/Schreiben großer Dateien kann andere Vorgänge blockieren.
• Asynchron: Asynchrone Datei-E/A-Vorgänge mithilfe von Aiofiles können die Leistung verbessern, indem sie die gleichzeitige Ausführung anderer Aufgaben ermöglichen.

Wahl zwischen synchron und asynchron

• Verwenden Sie synchrone Programmierung für CPU-gebundene Aufgaben, bei denen die Vorgänge rechenintensiv sind und von der sequentiellen Ausführung profitieren.
• Verwenden Sie asynchrone Programmierung für E/A-gebundene Aufgaben, bei denen die Vorgänge das Warten auf externe Ressourcen beinhalten, wie z. B. Netzwerkanforderungen, Datei-E/A oder Datenbankabfragen.

Anwendungsbeispiel für Echtzeit-Messaging
Erstellen wir eine einfache Echtzeit-Messaging-Anwendung mit FastAPI für das Backend und WebSockets für die Echtzeitkommunikation. Wir verwenden Streamlit für das Frontend, um Nachrichten anzuzeigen.

Backend (FastAPI + WebSockets)

1.Abhängigkeiten installieren:
pip install fastapi uvicorn websockets

2.Backend-Code (backend.py):

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.responses import HTMLResponse
from typing import List

app = FastAPI()

class ConnectionManager:
    def __init__(self):
        self.active_connections: List[WebSocket] = []

    async def connect(self, websocket: WebSocket):
        await websocket.accept()
        self.active_connections.append(websocket)

    def disconnect(self, websocket: WebSocket):
        self.active_connections.remove(websocket)

    async def send_message(self, message: str):
        for connection in self.active_connections:
            await connection.send_text(message)

manager = ConnectionManager()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await manager.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            await manager.send_message(data)
    except WebSocketDisconnect:
        manager.disconnect(websocket)

@app.get("/")
async def get():
    return HTMLResponse("""
    <!DOCTYPE html>
    <html>
    <head>
        <title>Chat</title>
    </head>
    <body>
        <h1>WebSocket Chat</h1>
        <form action="" onsubmit="sendMessage(event)">
            <input type="text" id="messageText" autocomplete="off"/>
            <button>Send</button>
        </form>
        <ul id='messages'>
        </ul>
        <script>
            var ws = new WebSocket("ws://localhost:8000/ws");
            ws.onmessage = function(event) {
                var messages = document.getElementById('messages');
                var message = document.createElement('li');
                message.appendChild(document.createTextNode(event.data));
                messages.appendChild(message);
            };

            function sendMessage(event) {
                var input = document.getElementById("messageText");
                ws.send(input.value);
                input.value = '';
                event.preventDefault();
            }
        </script>
    </body>
    </html>
    """)

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Frontend (Streamlit)

1. Abhängigkeiten installieren:

pip install streamlit websocket-client

1. Frontend-Code (frontend.py):

import streamlit as st
import asyncio
import threading
from websocket import create_connection, WebSocket

st.title("Real-time Messaging Application")

if 'messages' not in st.session_state:
    st.session_state.messages = []

def websocket_thread():
    ws = create_connection("ws://localhost:8000/ws")
    st.session_state.ws = ws
    while True:
        message = ws.recv()
        st.session_state.messages.append(message)
        st.experimental_rerun()

if 'ws' not in st.session_state:
    threading.Thread(target=websocket_thread, daemon=True).start()

input_message = st.text_input("Enter your message:")

if st.button("Send"):
    if input_message:
        st.session_state.ws.send(input_message)
        st.session_state.messages.append(f"You: {input_message}")

st.subheader("Chat Messages:")
for message in st.session_state.messages:
    st.write(message)

Ausführen der Anwendung

1. Starten Sie das FastAPI-Backend:

uvicorn backend:app

1. Starten Sie das Streamlit-Frontend:

streamlit run frontend.py

Erklärung
Backend (backend.py):

• Die FastAPI-App verfügt über einen WebSocket-Endpunkt unter /ws.
• ConnectionManager verwaltet WebSocket-Verbindungen und sendet Nachrichten an alle verbundenen Clients.
• Der Root-Endpunkt (/) dient als einfache HTML-Seite zum Testen der WebSocket-Verbindung.

Frontend (frontend.py):

• Streamlit-App stellt eine Verbindung zum WebSocket-Server her und wartet auf eingehende Nachrichten.
• Ein separater Thread verwaltet die WebSocket-Verbindung, um ein Blockieren der Streamlit-App zu verhindern.
• Benutzer können über das Eingabefeld Nachrichten senden, die dann an den WebSocket-Server gesendet und im Chat angezeigt werden.

Dieses Beispiel zeigt eine einfache Echtzeit-Messaging-Anwendung, die FastAPI und WebSockets für das Backend und Streamlit für das Frontend verwendet.

Das obige ist der detaillierte Inhalt vonSynchrone und asynchrone Programmierung in Python: Schlüsselkonzepte und Anwendungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!