Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Asincronacht agus Dea-Chleachtais

Ceacht 13 as 14 Nuashonraithe 2 Samhain 2026 Ardleibhéal
Ar an leathanach seo
  1. I/A Asincronach: Riachtanas Teicniúil
  2. Roghnaigh Leabharlanna atá Asincronach go Dúchasach
  3. Nuair nach bhfuil Leagan Asincronach ann
  4. Gníomhaíochtaí Glana a Dearadh
  5. Príomhphointí

I/A Asincronach: Riachtanas Teicniúil

Caithfidh gach gníomhaíocht i Mistral Workflows oibríochtaí ionchuir/aschuir asincronacha a úsáid. Ní moladh stíle é seo; srian teicniúil atá ann. Reáchtáil chomhthreomhar a chuireann glaonna blocála cosúil le requests.post() ar an obairí ar fad ar ceal agus coscaíonn sé aon ghníomhaíocht eile ó rith.

Eascraíonn an riachtanas seo ó ailtireacht an oibreora, a fheidhmíonn gníomhaíochtaí laistigh de lúba imeachta asyncio. Nuair a fhanann coraitín le freagra líonra go hasincronach, tugann sé smacht ar ais don lúb, rud a ligeann do ghníomhaíochtaí eile dul ar aghaidh. I gcodarsnacht leis sin, ní thugann glaonna comhthreomhara aon smacht ar ais.

import requests

# MÍCHEART: Blocálann sé an t-oibreoir ar fad
@workflows.activity()
async def blocking_activity(url: str) -> dict:
    # Is comhthreomhar é requests.post() — blocálann sé an lúb imeachta
    response = requests.post(url, json={"query": "test"})
    return response.json()

Is féidir leis an siomptóm sa táirgeadh a bheith mearbhallach: seolann tú deich ngníomhaíocht i gcomhthráth le asyncio.gather, ach feidhmíonn siad ceann i ndiaidh a chéile i ndáiríre. Má fhanann gach ceann dhá shoicind le haghaidh API i gcéin, tomhaiseann tú fiche soicind in ionad an dá shoicind a bhí súil leo, gan aon earráidí a thógáil.

Roghnaigh Leabharlanna atá Asincronach go Dúchasach

Is é an réiteach gach leabharlann bhlocála a chur in ionad a leagan comhionann asincronach. I gcás glaonna HTTP, is é httpx an rogha réamhshocraithe.

import httpx

# CEART: Gan blocáil
@workflows.activity()
async def async_activity(url: str) -> dict:
    async with httpx.AsyncClient() as client:
        response = await client.post(url, json={"query": "test"})
    return response.json()

Freastalaíonn aiohttp ar an gcuspóir céanna le API beagán difriúil bunaithe ar sheisiúin.

import aiohttp

@workflows.activity()
async def aiohttp_activity(url: str) -> dict:
    async with aiohttp.ClientSession() as session:
        async with session.post(url, json={"query": "test"}) as response:
            return await response.json()

I gcás bunachair shonraí, téann asyncpg in ionad psycopg2 do PostgreSQL. Tabhair faoi deara an bloc try/finally: caithfear an nasc a dhúnadh fiú má ardaíonn an cheist earráid. Murach sin, ídeoidh iarrachtaí athfhillteacha an linn naisc.

import asyncpg

# CEART: Tiománaí Asincronach PostgreSQL
@workflows.activity()
async def async_db_query(user_id: str) -> dict:
    conn = await asyncpg.connect("postgresql://user:pass@localhost/db")
    try:
        row = await conn.fetchrow(
            "SELECT * FROM users WHERE id = $1", user_id
        )
        return dict(row) if row else {"error": "user not found"}
    finally:
        await conn.close()

Leanann rochtain ar chomhaid an loighic chéanna le aiofiles, fiú do chomhaid bheaga ina mbeifeá buartha faoi open() a úsáid fós.

import aiofiles

# CEART: Léamh comhad asincronach
@workflows.activity()
async def read_file_async(path: str) -> dict:
    async with aiofiles.open(path, mode="r") as f:
        content = await f.read()
    return {"content": content, "size": len(content)}

Níl SDK Mistral féin eisceachtúil: tá leagan ag gach modh atá iarmhírthe ag _async, agus is é sin an ceann ba chóir duit a ghlaowh ó ghníomhaíocht.

from mistralai.client import Mistral

@workflows.activity()
async def call_mistral(prompt: str) -> dict:
    client = Mistral()
    # Úsáid complete_async, NÍ complete
    response = await client.chat.complete_async(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}]
    )
    return {"response": response.choices[0].message.content}

Coinnigh an tábla mapála seo ar láimh le linn athbhreithnithe cód: is fabht feidhmíochta féideartha é aon líne ón gcolún clé a fheictear i ngníomhaíocht.

OibríochtMícheart (blocála)Ceart (asincronach)
HTTPrequests.get()httpx.AsyncClient().get()
HTTPurllib.request.urlopen()aiohttp.ClientSession().get()
PostgreSQLpsycopg2.connect()asyncpg.connect()
MySQLmysql.connector.connect()aiomysql.connect()
Redisredis.Redis()redis.asyncio.Redis()
Comhaidopen()aiofiles.open()
Codladhtime.sleep()asyncio.sleep()
Mistralclient.chat.complete()client.chat.complete_async()

Nuair nach bhfuil Leagan Asincronach ann

Ní thugann roinnt leabharlann gnó, cosúil le SDK dílseánaigh nó cliant seanbhunaithe, leagan asincronach ar bídís. Sa chás seo, ligeann asyncio.to_thread() duit an cód blocála a rith i snáithe ar leith gan an lúb imeachta a reo.

import asyncio
from some_library import blocking_function

@workflows.activity()
async def compatibility_activity(params: dict) -> dict:
    """Clúdaíonn sé glaonna blocála i snáithe."""
    result = await asyncio.to_thread(
        blocking_function,
        params["arg1"],
        params["arg2"]
    )
    return {"result": result}

Is comhréiteach é seo, ní réiteach comhionann: ídíonn gach glaó snáithe ón linn, atá teoranta ó thaobh méide de. I gcás gníomhaíochta a ghlaotar go maiveach i gcomhthráth, ní dhéanann tú ach an bac a aistriú seachas é a bhaint. Is fearr i gcónaí leabharlann atá asincronach go dúchasach a úsáid nuair atá ceann ar fáil.

Gníomhaíochtaí Glana a Dearadh

Thar asincronacht, is iad ceithre nós a dhéanann idirdhealú idir gníomhaíocht láidir agus ceann a chuirfidh uaireanta de bhriseadh ceann ort.

Is é an chéad cheann ná raon feidhme. Ba chóir freagracht amháin agus gan ach ceann amháin a bheith ag gníomhaíocht, toisc gurb é an t-aonad athfhillte agus marthanachta é freisin: déanfaidh gníomhaíocht uileghabhálach a theipeann agus é ag seoladh ríomhphoist an t-asbhaint agus an anailís a athsheinm ón tús.

# MAITH: Tá freagracht shoiléir ag gach gníomhaíocht
@workflows.activity()
async def extract_text(url: str) -> dict:
    # ...
    pass

@workflows.activity()
async def analyze_sentiment(text: str) -> dict:
    # ...
    pass

# OLc: Gníomhaíocht uileghabhálach
@workflows.activity()
async def do_everything(url: str) -> dict:
    text = ...  # asbhaint
    sentiment = ...  # anailís
    # seol ríomhphost
    # sábháil chuig DB
    pass

Baineann an dara ceann le hacmhainní. Ráthaíonn bainisteoir comhthéacs async with go ndúntar an cliant fiú má tharlaíonn earráid, rud a dhéanann glaonna láimhe dearmad go minic sooner nó later.

@workflows.activity()
async def clean_request(params: dict) -> dict:
    # Úsáid async with chun dúnadh a ráthú
    async with httpx.AsyncClient() as client:
        response = await client.get(params["url"])
    # Dúntar an cliant go huathoibríoch anseo
    return response.json()

Tá an tríú ceann níos fíneálta: ní tuilleann gach earráid iarracht athfhillte. Is sealadach iad teorainn ama, 429, nó 500 agus ba chóir dóibh teacht chun cinn chun athfhillte a spreagadh. Léiríonn earráid 4xx, áfach, iarratas neamhbhailí nach réiteoidh trí iarracht athfhillte é. Ina ionad sin, fill toradh sainráite agus lig don sreabhadh oibre cinneadh a dhéanamh.

@workflows.activity(
    start_to_close_timeout=timedelta(minutes=2),
    retry_policy_max_attempts=3,
)
async def robust_activity(params: dict) -> dict:
    async with httpx.AsyncClient(timeout=60) as client:
        try:
            response = await client.post(params["url"], json=params["data"])
            response.raise_for_status()
            return {"status": "success", "data": response.json()}
        except httpx.TimeoutException:
            raise  # Déanfar athfhillte air ag an ardán
        except httpx.HTTPStatusError as e:
            if e.response.status_code == 429:
                raise  # Ráta teoranta — déanfar athfhillte air
            elif e.response.status_code >= 500:
                raise  # Earráid freastalaí — déanfar athfhillte air
            else:
                # Earráid cliant (4xx) — ná déan athfhillte
                return {"status": "error", "code": e.response.status_code}

Ar deireadh, eascraíonn an ceathrú nós as an teorainn 2 MB in aghaidh na nglaonna: ná fill ach an méid atá ag teastáil ón sreabhadh oibre chun an chéad chéim eile a chinneadh. Is leor beagnach i gcónaí comhaireamh, sampla, agus an URL chuig an toradh iomlán.

@workflows.activity()
async def extract_data(source: str) -> dict:
    data = await retrieve_large_data(source)

    # Fill ach an méid atá ag teastáil ón sreabhadh oibre
    return {
        "item_count": len(data),
        "summary": data[:10],  # Ní ach an chéad 10
        "full_url": await upload_results(data)
    }

Príomhphointí

  • Tá I/A Asincronach éigeantach: úsáid httpx, asyncpg, aiofiles in ionad a gcomhpháirtithe comhthreomhara
  • Reoíonn glaonna blocála (requests, psycopg2, open) an t-oibreoir ar fad
  • Úsáid asyncio.to_thread() mar rogha dheireanach do leabharlanna gan leagan asincronach
  • Caithfidh freagracht shoiléir amháin a bheith ag gach gníomhaíocht
  • Dún naisc i gcónaí le async with
  • Láimhseáil earráidí go sainráite: ba chóir athfhillte a dhéanamh ar chuid acu, ach ní ar chuid eile
  • Teorainn a chur le méideanna fillte chun fanacht faoin teorainn 2 MB