Munkafolyamat-végrehajtási módok

Munkafolyamat .NET-ben való futtatásakor a végrehajtási mód vezérli a szuperlépések feldolgozását és az események fogyasztóhoz való eljuttatását. Az InProcessExecution osztály két végrehajtási módot tesz elérhetővé: OffThread és Lockstep.

Overview

	OffThread (alapértelmezett)	Zárolás
Superstep-végrehajtás	Háttérszál	Fogyasztói szál
Eseménykézbesítés	Azonnali, ahogy az események felmerülnek	Minden szupersztep befejezése után kötegelve
Lépés végrehajtása	Eseményfeldolgozástól függetlenül	Szüneteltetve, amíg a köteges események feldolgozásra kerülnek
Konkurencia	A fogyasztó felolvassa az eseményeket, miközben a szupersteps fut	A fogyasztó és a szuperlépés-végrehajtás váltakozik
A legjobb ehhez:	Valós idejű streamelés, éles forgatókönyvek	Tesztelés, hibakeresés, determinisztikus rendezés

OffThread

Az OffThread az alapértelmezett végrehajtási mód. A Supersteps egy háttérszálon fut, és az eseményeket azonnal továbbítják, amint azok a csatornaalapú implementáción keresztül létrejönnek.

// OffThread is the default — these are equivalent:
await using StreamingRun run = await InProcessExecution.RunStreamingAsync(workflow, input);
await using StreamingRun run = await InProcessExecution.OffThread.RunStreamingAsync(workflow, input);

Hogyan működik?

1. A háttérfeladat folyamatosan futtat szupersztepseket, amíg az üzenetek függőben vannak.
2. Mivel a végrehajtók kimeneteket vagy eseményeket hoznak létre, az eredményül kapott WorkflowEvent objektumokat egy kötetlen Channel<WorkflowEvent>-be írják.
3. A kliens az eseményeket a csatornán keresztül olvassa be WatchStreamAsync, és valós időben fogadja őket, ahogy keletkeznek.
4. Ha az összes szuperlépés befejeződött, és nem marad üzenet, a futtatás leáll egy Idle vagy PendingRequests állapottal.

Mivel a superstep ciklus és a fogyasztó egyidejűleg fut, az események azonnal megjelennek, amint azok felmerülnek – nincs pufferelési késleltetés. Ez ideálissá teszi az OffThreadot olyan streamelési forgatókönyvekhez, ahol az alacsony késésű eseménykézbesítés számít, például jogkivonatonkénti frissítések megjelenítése a felhasználói felületen.

Egyidejű futtatások

Az OffThread egy egyidejű változatot is támogat, amely lehetővé teszi, hogy egyszerre több futtatás is ugyanazt a munkafolyamat-példányt ossza meg:

await using StreamingRun run = await InProcessExecution.Concurrent.RunStreamingAsync(workflow, input);

Important

Az egyidejű végrehajtáshoz a munkafolyamat összes végrehajtóját deklarálni crossRunShareable kell (a konstruktoron), vagy gyári metódusként kell megadni.

Zárolás

Lockstep módban a szuperlépések a fogyasztó szálában futnak, nem pedig egy háttérfeladaton. Az események minden szupersztep során halmozódnak fel, és a szupersztep befejeződése után kötegként bocsátják ki.

await using StreamingRun run = await InProcessExecution.Lockstep.RunStreamingAsync(workflow, input);

Hogyan működik?

1. A fogyasztó meghívja WatchStreamAsynca végrehajtási ciklust.
2. A superstep a befejezésig fut, és az események egy várólistában halmozódnak fel.
3. A szuperstep befejezése után az összes várólistán lévő eseményt a rendszer a fogyasztónak adja.
4. A következő szuperlépés csak azután kezdődik, hogy a fogyasztó megkapta az összes eseményt az előző lépésből.

Ez a váltakozó minta azt jelenti, hogy a fogyasztó és a munkafolyamat-motor soha nem fut egyszerre. Az eseménykézbesítés determinisztikus – a szuperstep összes eseménye garantáltan a következő szupersztep eseményei előtt érkezik.

Mikor érdemes használni a Lockstep-et?

A Lockstep akkor hasznos, ha:

• Tesztelés – a determinisztikus eseményrendezés egyértelművé teszi az állításokat.
• Hibakeresés – a lépésről lépésre hibakeresés egyszerűbb, ha a végrehajtás a fogyasztó szálán marad.
• Rendezett feldolgozás – olyan forgatókönyvek, ahol egy szuperstep eseményének teljes feldolgozására van szükség a következő szuperstep kezdete előtt.

Végrehajtási mód kiválasztása

Az alapértelmezett OffThread módot a legtöbb éles forgatókönyv esetében ajánljuk. Ez biztosítja a legjobb válaszkészséget, és lehetővé teszi a munkafolyamat számára a feldolgozás folytatását, miközben a fogyasztó kezeli az eseményeket.

Akkor használja a Lockstepet, ha a determinisztikus viselkedés fontosabb a teljesítménynél, például egységtesztekben vagy hibakeresési munkamenetekben.

// Production: OffThread (default)
await using StreamingRun run = await InProcessExecution.RunStreamingAsync(workflow, input);

// Testing: Lockstep for deterministic behavior
await using StreamingRun run = await InProcessExecution.Lockstep.RunStreamingAsync(workflow, input);

Nem-streamelő végrehajtás

Mindkét végrehajtási mód támogatja a nem streamelő végrehajtás-t a RunAsync által. Nem streamelési módban a munkafolyamat a befejezésig fut, és az összes eseményt egy Run objektumba gyűjti ahelyett, hogy növekményesen streameli őket:

Run run = await InProcessExecution.RunAsync(workflow, input);

// Access all emitted events
foreach (WorkflowEvent evt in run.OutgoingEvents)
{
    // Process events
}

Mivel a nem streamelt végrehajtás az összes eseményt összegyűjti a befejezés után, az OffThread valós idejű eseménykézbesítési előnye nem érvényes. A nem streamelési forgatókönyvekben a módok közötti elsődleges különbség a szálkezelés: az OffThread szuperstepseket futtat egy háttérszálon, felszabadítva a hívó szálat a befejezésre várva, míg a Lockstep szupersteps-eket futtat a hívó szálán, és blokkolja azt, amíg a munkafolyamat befejeződik.

A nem streameléses végrehajtás az alapértelmezett OffThread módot használja. A Lockstep használata nem streameléses végrehajtással:

Run run = await InProcessExecution.Lockstep.RunAsync(workflow, input);

Következő lépések

Munkafolyamat-szerkesztő és -végrehajtás

A végrehajtási módok nem alkalmazhatók a Python-munkafolyamatokra. A Python-munkafolyamatok egyetlen végrehajtási modellt használnak, amely egy aszinkron generátoron keresztül kezeli a szupersztep-feldolgozást és az eseménykézbesítést. Ez a modell hasonló a .NET Lockstep üzemmódhoz – a lépések nem lépnek előre, csak akkor, ha a fogyasztó aktívan lekéri az eseményeket a generátorból.

A Python-munkafolyamatok futtatásával kapcsolatos információkért tekintse meg a Workflow Builder > Végrehajtás című témakört.

Munkafolyamat Go-ban való futtatásakor a végrehajtási környezet szabályozza a szuperstepsek feldolgozását és az események fogyasztónak való kézbesítését. A workflow/inproc csomag három környezetet tesz elérhetővé: Default/OffThread, Lockstepés .Concurrent

Overview

	OffThread / Default	Zárolás	Egyidejű
Superstep-végrehajtás	Háttér goroutine	Az eseményfogyasztó által vezérelt	Háttér goroutine
Eseménykézbesítés	Azonnali, ahogy az események felmerülnek	Kötegelve az adatfolyam feldolgozása közben	Azonnali, ahogy az események felmerülnek
A legjobb ehhez:	Valós idejű streamelés, éles forgatókönyvek	Tesztelés, hibakeresés, egy teljes szuperstep figyelése egyenként	Megosztott munkafolyamat-példányok egyidejűleg biztonságos kötésekkel

OffThread

Az OffThread az alapértelmezett végrehajtási mód. Ezek egyenértékűek:

stream, err := inproc.Default.RunStreaming(ctx, wf, input)
stream, err := inproc.OffThread.RunStreaming(ctx, wf, input)

Hogyan működik?

1. A háttérben futó goroutine szuperlépéseket hajt végre, amíg vannak függőben lévő üzenetek.
2. Mivel a végrehajtók kimeneteket vagy eseményeket hoznak létre, a munkafolyamat-események a streambe lesznek írva.
3. A fogyasztó a WatchStream használatával olvassa az eseményeket, és azok előállításával egyidejűleg kapja meg őket.
4. Amikor az összes szuperlépés befejeződik, és nem maradnak üzenetek, a futás tétlen vagy függő kérelem állapotban leáll.

Egyidejű futtatások

Akkor használható inproc.Concurrent , ha a munkafolyamat összes végrehajtó kötése támogatja az egyidejű közös végrehajtást:

stream, err := inproc.Concurrent.RunStreaming(ctx, wf, input)
if err != nil {
    return err
}
defer stream.Close(ctx)

Zárolás

Lockstep módban a munkafolyamat végrehajtása a fogyasztó streamből történő olvasásával összhangban halad előre. Az egyik szuperstep eseményei a következő superstep futtatása előtt lesznek kézbesítve.

A szupersztepben lévő végrehajtók továbbra is párhuzamosan futnak. A Lockstep nem garantálja a rögzített sorrendet a saját eseményei vagy eredményei között.

stream, err := inproc.Lockstep.RunStreaming(ctx, wf, input)
if err != nil {
    return err
}
defer stream.Close(ctx)

for evt, err := range stream.WatchStream(ctx) {
    if err != nil {
        return err
    }
    // inspect event
}

Hogyan működik?

1. A fogyasztó meghívja WatchStreama végrehajtási ciklust.
2. Egy szuperstep-futtatás befejeződik, és az események halmozódnak fel.
3. A felhalmozott események a fogyasztóhoz kerülnek.
4. A következő szupersztep csak azután kezdődik, hogy a fogyasztó megkapja az előző szupersztephez tartozó eseményeket.

Mikor érdemes használni a Lockstep-et?

Akkor használja a Lockstepet, ha az egyik szuperstep eseményét a következő szuperstep kezdete előtt kell feldolgoznia, például tesztekben vagy hibakeresésben. Ne feltételezzen sorrendet a független végrehajtók között ugyanazon a lépésen belül.

Végrehajtási mód kiválasztása

A legtöbb éles forgatókönyv esetében használja inproc.Default vagy inproc.OffThread. A fogyasztó által vezérelt szuperstep-progresszióhoz használja a(z) inproc.Lockstep elemet. Csak akkor használható inproc.Concurrent , ha minden kötés támogatja az egyidejű munkafolyamatok futtatását; nem szabályozza a végrehajtók közötti egyidejűséget egy szupersztepben.

// Production: OffThread (default)
stream, err := inproc.Default.RunStreaming(ctx, wf, input)
if err != nil {
    return err
}
defer stream.Close(ctx)

// Testing: consume a complete superstep before the next one runs.
testStream, err := inproc.Lockstep.RunStreaming(ctx, wf, input)
if err != nil {
    return err
}
defer testStream.Close(ctx)

Nem-streamelő végrehajtás

Az összes végrehajtási környezet támogatja a nem streamelő Run módot is, amely a következő leállásig fut, és a kibocsátott eseményeket a visszaadott futtatásban tárolja.

run, err := inproc.Default.Run(ctx, wf, input)
if err != nil {
    return err
}

for evt := range run.NewEvents() {
    if output, ok := evt.(workflow.OutputEvent); ok {
        fmt.Printf("Final result: %v\n", output.Output)
    }
}

Következő lépések

Munkafolyamat-szerkesztő és -végrehajtás