Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Χρήση σηματοφόρων για τον περιορισμό ταυτόχρονων αιτημάτων

Μάθημα 4 / 12 Ενημερώθηκε 30 Ιουλίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Το πρόβλημα της ανεξέλεγκτης συγχρονικότητας
  2. Πώς λειτουργούν οι σηματοφόροι
  3. Πλήρες μοτίβο με το OpenAI SDK
  4. Επιλογή της σωστής τιμής για τον σηματοφόρο
  5. Συχνό λάθος: καθολικός vs τοπικός σηματοφόρος
  6. Βασικά σημεία

Το πρόβλημα της ανεξέλεγκτης συγχρονικότητας

Η εκτόξευση όλων των αιτημάτων σας παράλληλα χωρίς όρια είναι ένα συχνό λάθος. Αν έχετε 200 ερωτήσεις προς επεξεργασία και τις ξεκινήσετε όλες ταυτόχρονα, θα χτυπήσετε τα όρια ρυθμού (rate limits) του API, θα λάβετε σφάλματα HTTP 429 και ενδέχεται το κλειδί API σας να αποκλειστεί προσωρινά.

Ο σηματοφόρος (semaphore) είναι η τυπική λύση για τον έλεγχο του αριθμού των ταυτόχρονων αιτημάτων. Πρόκειται για έναν μετρητή που επιτρέπει σε έναν μέγιστο αριθμό coroutines να εκτελούνται παράλληλα.

5
Προτεινόμενα παράλληλα αιτήματα
429
Σφάλμα ορίου ρυθμού HTTP
RPM
Αιτήματα ανά λεπτό
TPM
Tokens ανά λεπτό

Πώς λειτουργούν οι σηματοφόροι

Το asyncio.Semaphore λειτουργεί ως κλείδωμα μετρητή. Όταν μια coroutine εισέρχεται στο μπλοκ async with semaphore, ο μετρητής μειώνεται. Όταν εξέρχεται, ο μετρητής αυξάνεται. Αν ο μετρητής φτάσει στο μηδέν, οι επόμενες coroutines περιμένουν μέχρι να ελευθερωθεί μια θέση.

import asyncio
from asyncio import Semaphore

semaphore = Semaphore(5)  # μέγιστο 5 ταυτόχρονα αιτήματα

async def process_request(request: str):
    async with semaphore:
        # Αυτή η ενότητα περιορίζεται σε 5 παράλληλες εκτελέσεις
        chat = client.chat.create(
            model="grok-4.20-0309-reasoning",
            max_tokens=100
        )
        chat.append(user(request))
        return await chat.sample()

Σε αυτό το παράδειγμα, ακόμα κι αν ξεκινήσετε 100 coroutines με το asyncio.gather, μόνο 5 θα εκτελούνται ταυτόχρονα. Οι υπόλοιπες 95 θα περιμένουν τη σειρά τους.

Πλήρες μοτίβο με το OpenAI SDK

Ακολουθεί το ίδιο μοτίβο χρησιμοποιώντας το AsyncOpenAI, το οποίο προτιμάται συχνά για λόγους συμβατότητας:

from openai import AsyncOpenAI
import httpx

client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

async def send_request(sem: Semaphore, request: str) -> dict:
    async with sem:
        return await client.chat.completions.create(
            model="grok-4.20-0309-reasoning",
            messages=[{"role": "user", "content": request}]
        )

async def process_all(requests: list[str], max_concurrent: int = 5):
    sem = Semaphore(max_concurrent)
    tasks = [send_request(sem, r) for r in requests]
    return await asyncio.gather(*tasks)

Η παράμετρος max_concurrent είναι ρυθμιζόμενη. Ορίστε την με βάση τα όρια ρυθμού σας (μάθημα 7).

Επιλογή της σωστής τιμής για τον σηματοφόρο

Υπολογίστε τη βέλτιστη τιμή από τα όρια ρυθμού σας, αλλά όχι άμεσα: πρέπει να συνυπολογίσετε τη διάρκεια του αιτήματος. Αν το πακέτο σας επιτρέπει 60 RPM και κάθε αίτημα διαρκεί περίπου 10 δευτερόλεπτα, ένας σηματοφόρος με τιμή 5 παράγει το πολύ 5 ταυτόχρονα αιτήματα, ή περίπου 30 αιτήματα ανά λεπτό—άνετα κάτω από το όριο. Εφαρμόστε αυτή τη συλλογιστική (όριο RPM × μέση διάρκεια ÷ 60) στη δική σας περίπτωση. Αυτό εξηγεί γιατί τα μοντέλα συλλογισμού (reasoning models) απαιτούν χαμηλότερο σηματοφόρο: τα αιτήματά τους διαρκούν περισσότερο, οπότε με ίση συγχρονικότητα, η απόδοση ανά λεπτό μειώνεται και ο κίνδυνος στιγμιαίου κορεσμού αυξάνεται. Σε περίπτωση αμφιβολίας, η εμπειρική προσέγγιση είναι η πιο ασφαλής: ξεκινήστε χαμηλά, μεταξύ 3 και 5, παρατηρήστε τον ρυθμό σφαλμάτων 429 και αυξήστε σταδιακά μέχρι να βρείτε την ισορροπία μεταξύ απόδοσης και σταθερότητας.

Κατά προσέγγιση υπολογισμός

Αιτήματα ανά λεπτό = σηματοφόρος * (60 / μέση_διάρκεια_δευτερόλεπτα)

Παράδειγμα: σηματοφόρος=5, διάρκεια=10δ → 5 * (60/10) = 30 RPM
Παράδειγμα: σηματοφόρος=10, διάρκεια=5δ → 10 * (60/5) = 120 RPM

Συχνό λάθος: καθολικός vs τοπικός σηματοφόρος

# ΚΑΚΟ: νέος σηματοφόρος σε κάθε κλήση
async def bad_request(request: str):
    sem = Semaphore(5)  # κάθε κλήση δημιουργεί τον δικό της σηματοφόρο
    async with sem:
        return await client.chat.completions.create(...)

# ΚΑΛΟ: σηματοφόρος κοινός σε όλες τις κλήσεις
sem = Semaphore(5)

async def good_request(request: str):
    async with sem:
        return await client.chat.completions.create(...)

Ο σηματοφόρος πρέπει να είναι κοινός σε όλες τις coroutines. Αν τον δημιουργείτε τοπικά μέσα σε κάθε συνάρτηση, κάθε coroutine θα έχει τον δικό της σηματοφόρο και το όριο δεν θα λειτουργήσει.

Βασικά σημεία

  • Ένας σηματοφόρος περιορίζει τον αριθμό των ταυτόχρονων αιτημάτων API για να τηρούνται τα όρια ρυθμού
  • Χρησιμοποιήστε το async with semaphore για να προστατεύσετε τις κλήσεις API
  • Ξεκινήστε με μια τιμή από 3 έως 5 και προσαρμόστε την με βάση τα όρια RPM σας
  • Ο σηματοφόρος πρέπει να είναι κοινόχρηστος (καθολικός ή περασμένος ως παράμετρος), ποτέ να μην δημιουργείται τοπικά
  • Ο τύπος RPM = σηματοφόρος * (60 / μέση_διάρκεια) βοηθά στον καθορισμό της τιμής