Mode Eksekusi Alur Kerja

Saat menjalankan alur kerja di .NET, mode eksekusi mengendalikan cara supersteps diproses dan bagaimana event dikirimkan kepada konsumen. Kelas InProcessExecution ini mengekspos dua mode eksekusi: OffThread dan Lockstep.

Overview

OffThread (Bawaan) Lockstep
Superstep eksekusi Thread latar belakang Diskusi konsumen
Pengiriman peristiwa Segera, saat kejadian terpicu Diolah dalam batch setelah setiap superstep selesai
Eksekusi langkah-langkah Mandiri dari pemrosesan acara Dijeda hingga acara yang dibatch dikonsumsi
Konkurensi Konsumen membaca peristiwa saat supersteps berjalan Pengoperasian konsumen dan superstep dilakukan secara bergantian.
Terbaik untuk Streaming real time, skenario produksi Pengujian, penelusuran kesalahan, pemrosesan terurut secara deterministik

OffThread

OffThread adalah mode eksekusi bawaan. Supersteps berjalan pada thread latar belakang, dan event mengalir segera setelah dipicu melalui implementasi berbasis channel.

// 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);

Cara kerjanya

  1. Tugas latar belakang menjalankan supersteps terus menerus saat pesan tertunda.
  2. Saat eksekutor menghasilkan output atau peristiwa, objek WorkflowEvent yang dihasilkan ditulis ke Channel<WorkflowEvent> yang tidak terbatas.
  3. Konsumen membaca peristiwa dari saluran melalui WatchStreamAsync, menerimanya secara real time saat diproduksi.
  4. Ketika semua supersteps selesai dan tidak ada pesan yang tersisa, eksekusi berhenti dengan status Idle atau PendingRequests .

Karena loop superstep dan konsumen berjalan bersamaan, peristiwa muncul segera setelah dinaikkan - tidak ada penundaan buffering. Ini menjadikan OffThread sangat ideal untuk skenario streaming di mana pengiriman peristiwa dengan latensi rendah sangat penting, seperti dalam menampilkan pembaruan setiap token di antarmuka pengguna (UI).

Proses yang berjalan bersamaan

OffThread juga mendukung varian bersamaan yang memungkinkan beberapa eksekusi berbagi instans alur kerja yang sama secara bersamaan:

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

Important

Eksekusi simultan mengharuskan semua pelaksana dalam alur kerja dideklarasikan crossRunShareable (pada konstruktor) atau disediakan sebagai metode pembuat.

Lockstep

Dalam mode Lockstep, supersteps berjalan di utas konsumen daripada pada tugas latar belakang. Peristiwa diakumulasikan selama setiap superstep dan dikeluarkan sebagai batch setelah superstep selesai.

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

Cara kerjanya

  1. Konsumen memanggil WatchStreamAsync, yang menggerakkan loop eksekusi.
  2. Superstep berjalan hingga selesai, dan event diakumulasikan dalam antrean.
  3. Setelah superstep selesai, semua peristiwa yang diantrekan akan diserahkan kepada konsumen.
  4. Superstep berikutnya dimulai hanya setelah konsumen menerima semua peristiwa dari yang sebelumnya.

Pola bergantian ini berarti konsumen dan pengelola alur kerja tidak pernah beroperasi secara bersamaan. Pengiriman event bersifat deterministik — semua kejadian dalam satu superstep dijamin akan tiba sebelum kejadian apa pun dari superstep berikutnya.

Kapan menggunakan Lockstep

Lockstep berguna ketika:

  • Pengujian — urutan peristiwa deterministik membuat pernyataan mudah.
  • Penelusuran kesalahan — pelacakan langkah-langkah lebih mudah jika eksekusi tetap di utas konsumen.
  • Pemrosesan terurut — skenario di mana Anda perlu sepenuhnya memproses satu superstep sebelum superstep berikutnya dimulai.

Memilih Mode Eksekusi

Untuk sebagian besar skenario produksi, mode OffThread default disarankan. Ini memberikan responsivitas terbaik dan memungkinkan alur kerja untuk terus memproses saat konsumen menangani peristiwa.

Gunakan Lockstep ketika perilaku deterministik lebih penting daripada performa, seperti dalam pengujian unit atau sesi penelusuran kesalahan.

// 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);

Eksekusi Tanpa Streaming

Kedua mode eksekusi mendukung eksekusi non-streaming melalui RunAsync. Dalam mode non-streaming, alur kerja berjalan hingga selesai dan mengumpulkan semua peristiwa ke objek Run daripada mengalirkannya secara bertahap.

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

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

Karena eksekusi non-streaming mengumpulkan semua peristiwa setelah selesai, manfaat pengiriman peristiwa real time offThread tidak berlaku. Perbedaan utama antara mode dalam skenario non-streaming adalah utas: OffThread menjalankan supersteps pada utas latar belakang, membebaskan utas panggilan sambil menunggu penyelesaian, sedangkan Lockstep menjalankan supersteps pada utas pemanggil, memblokirnya hingga alur kerja selesai.

Eksekusi non-streaming menggunakan mode OffThread secara default. Untuk menggunakan Lockstep dengan pelaksanaan non-streaming:

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

Langkah berikutnya

Pembuat & Pelaksanaan Alur Kerja

Mode eksekusi tidak berlaku untuk alur kerja Python. Alur kerja Python menggunakan model eksekusi tunggal yang menangani pemrosesan superstep dan pengiriman peristiwa melalui generator asinkron. Model ini mirip dengan mode .NET Lockstep — langkah-langkah tidak maju kecuali konsumen secara aktif menarik peristiwa dari generator.

Untuk informasi tentang menjalankan alur kerja Python, lihat Penyusun & Eksekusi Alur Kerja.

Saat menjalankan alur kerja di Go, lingkungan eksekusi menentukan bagaimana langkah-langkah super diproses dan bagaimana peristiwa dikirimkan kepada penerima. Paket ini workflow/inproc mengekspos tiga lingkungan: Default/OffThread, , Lockstepdan .Concurrent

Overview

OffThread / Default Lockstep Konkurensi
Superstep eksekusi Goroutine latar belakang Didorong oleh konsumen event Goroutine latar belakang
Pengiriman peristiwa Segera, saat kejadian terpicu Dikelompokkan dalam batch saat stream diproses Segera, saat kejadian terpicu
Terbaik untuk Streaming real time, skenario produksi Pengujian, penelusuran kesalahan, pemrosesan terurut secara deterministik Instans alur kerja bersama dengan pengikatan yang aman bersamaan

OffThread

OffThread adalah mode eksekusi default. Ini setara:

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

Cara kerjanya

  1. Sebuah goroutine latar belakang menjalankan langkah-langkah super selama masih ada pesan yang tertunda.
  2. Saat pelaksana menghasilkan output atau peristiwa, peristiwa alur kerja ditulis ke aliran.
  3. Konsumen membaca event melalui WatchStream, dan menerimanya saat event tersebut dihasilkan.
  4. Ketika semua superstep selesai dan tidak ada pesan yang tersisa, eksekusi berhenti dengan status idle atau pending-request.

Proses yang berjalan bersamaan

Gunakan inproc.Concurrent saat semua pengikatan eksekutor dalam alur kerja mendukung eksekusi bersamaan:

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

Lockstep

Dalam mode Lockstep, eksekusi alur kerja berlanjut seiring konsumen membaca dari aliran data. Ini menjadikan urutan peristiwa deterministik untuk pengujian dan penelusuran kesalahan.

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
}

Cara kerjanya

  1. Konsumen memanggil WatchStream, yang menggerakkan loop eksekusi.
  2. Sebuah superstep dijalankan sampai selesai dan event diakumulasikan.
  3. Peristiwa yang terakumulasi diserahkan kepada konsumen.
  4. Superstep berikutnya baru dimulai setelah konsumen menerima event dari superstep sebelumnya.

Kapan menggunakan Lockstep

Gunakan Lockstep saat perilaku deterministik lebih penting daripada streaming berlatensi rendah, seperti dalam pengujian unit, debugging, atau skenario ketika Anda ingin memproses seluruh peristiwa dalam satu superstep sepenuhnya sebelum superstep berikutnya dimulai.

Memilih Mode Eksekusi

Untuk sebagian besar skenario produksi, gunakan inproc.Default atau inproc.OffThread. Gunakan inproc.Lockstep saat pemesanan peristiwa deterministik lebih penting daripada latensi streaming, seperti dalam pengujian. Gunakan inproc.Concurrent hanya ketika setiap pengikatan dalam alur kerja mendukung eksekusi bersamaan.

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

// Testing: Lockstep for deterministic behavior
testStream, err := inproc.Lockstep.RunStreaming(ctx, wf, input)
if err != nil {
    return err
}
defer testStream.Close(ctx)

Eksekusi Tanpa Streaming

Semua lingkungan eksekusi juga mendukung mode non-streaming Run, yang berjalan hingga penghentian berikutnya dan menyimpan kejadian yang dihasilkan pada run yang dikembalikan.

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)
    }
}

Langkah berikutnya

Pembuat & Pelaksanaan Alur Kerja

  • Last updated on