Home Search Pricing Get inErrata About

Sign in Sign up

Graph/async-lifecycle-leak

AntiPattern

Async Lifecycle Cancellation

async-lifecycle-leak

Async logic keeps running after component/GameObject destruction when raw Task.Delay is used, breaking expected lifecycle semantics; scheduling must be tied to the Component’s built-in task source and explicit schedule interruption. Without this, state leaks and behavior continues unexpectedly.

Node Details

Public graph metadata

Updated6/24/2026

Connections

30 linked nodes

MATCHESSolution

Use a cleanup function to clear the timeout, or simulate latency with Chrome DevTools throttling or MSW delay instead

MATCHESSolution

const usePermissionsStoreAsync = hook(usePermissionsStore, /*suspense*/false); — const YourComponent = () => {. Tension: if (userPermissions.isLoading) { return Loading... ; } if (userPermissions.error) { return An error occurred ; }. Outcome: Try Leo Query. It handle's async data for Zustand.

MATCHESSolution

Load the async user data with a Suspense-compatible async pattern (e.g., using `leo-query`’s `query`/`subscribe`) so the component waits until `currentUser` is available before rendering.

MATCHESSolution

Manage the refreshing state more robustly — ensuring it only turns off after all async operations are complete. Tension: remove the arbitrary timeout. Outcome: ensure no state updates occur after the component begins to unmount.

MATCHESSolution

Wrap updates that suspend with startTransition

MATCHESSolution

spawn it via `asyncio.create_task()` and store the task so you can cancel it on shutdown — Instead of awaiting `consume_messages()`. Outcome: store the task so you can cancel it on shutdown.

MATCHESSolution

single worker running async loop. Outcome: So you have a single worker running async loop and you block that loop.

MATCHESSolution

Move the persistence/cleanup logic into code that runs at the end of the background task (or otherwise extend lifecycle explicitly for the background task), rather than relying on the request-scoped `asynccontextmanager` teardown for those updates.

MATCHESSolution

Change the engine async fixture from session scope to function scope (remove scope="session") so all async fixtures/tests run on the same event loop, preventing the cross-loop Future/Task error.

MATCHESSolution

Using `asyncio.sleep()` in a loop is perfectly fine. Tension: every time you `await` the sleep, you effectively yield control back to the event loop. Outcome: calling `asyncio.sleep(0)` does not sleep at all, but only yields control back to the event loop.

MATCHESSolution

any time you have an I/O bound process with lots of idle time — waiting for user input, waiting for a TLS handshake. Tension: wrapping it in an async task can let other code run.

MATCHESSolution

Ensure the S3 download runs in a way that doesn’t block the event loop (i.e., only use asyncio `await` if the underlying operation is truly non-blocking, otherwise move it to a thread/executor). Use `asyncio.sleep()` in the scheduler loop to yield control back to the event loop between updates.

MATCHESSolution

bound it with a "progress ceiling" — a process emitting bytes but making NO semantic progress. Tension: a process emitting bytes but making NO semantic progress (livelock) would be shielded forever. Outcome: re-arms recovery after a long no-progress window even while bytes flow.

MATCHESSolution

An async function was passed to useActionState.

MATCHESSolution

Use a self-scheduling setTimeout (or otherwise manage interval setup/cleanup) so the next tick is scheduled only after the state update, with an exit condition like `seconds > 0` to stop when it reaches zero.

MATCHESSolution

To stop the Service from Activity — when the activity is destroyed. Tension: the service appears to remain active—its notification stays visible.

MATCHESSolution

future.cancel(true); — httpHardTimeoutScheduler.schedule(() -> {. Tension: if (!future.isDone() && !future.isCancelled()). Outcome: keep your latency low on your side of the wire.

MATCHESSolution

use another operator which creates one task per item — such as `delay` with zero delay. Tension: to get a better interleaving. Outcome: subject1.delay(0, TimeUnit.MILLISECONDS, scheduler).subscribe(log::info);.

MATCHESSolution

Use Component.Task (TaskSource) for all async work inside components — inside components. Tension: it auto-cancels when the component is destroyed.

MATCHESSolution

Add TemporaryEffect to GameObjects that should auto-destroy after effects finish — In the scene editor: add TemporaryEffect component to your effect prefab. Outcome: BecomeOrphan = true: if parent is destroyed, detach and finish playing.

MATCHESSolution

CollectSyncState() iterates all components, finds [Sync] properties without [Property], serializes them to JSON — in SaveSystem.cs. Tension: Use JSON serialization first, with a ByteStream/BytePack fallback for types that don't serialize cleanly to JSON. Outcome: RestoreSyncState() is called before RestoreNetworkOwnership() in the Load path.

MATCHESSolution

OnDisconnected destroys the PlayerData GameObject and removes the player from the UndoSystem. — GameManager implements INetworkListener. Tension: Clean up undo stacks. Outcome: OnDisconnected destroys the PlayerData GameObject and removes the player from the UndoSystem.

MATCHESSolution

call `body.DestroyGameObject()` in `OnOutOfBounds` — Implement `IScenePhysicsEvents` on your `GameObjectSystem`. Tension: prevents unbounded accumulation of out-of-world objects. Outcome: This is a one-liner that prevents unbounded accumulation of out-of-world objects.

MATCHESSolution

Capture a baseline in `ISceneLoadingEvents.OnLoad` — after `await Task.Yield()` to ensure all objects are spawned. Outcome: Use static fields to persist the baseline across `Game.ChangeScene()` calls.

MATCHESSolution

Use a two-level system: `ScheduleBase` (a sequence of tasks with a `ShouldCancel()` interrupt check) and `TaskBase` (a single atomic action with `OnStart/OnUpdate/OnEnd`). — The NPC calls `TickSchedule()` in `OnUpdate()` which runs the current schedule. Tension: When a task returns `Success`, the schedule advances to the next task. When `ShouldCancel()` returns true, the schedule returns `Interrupted` and the NPC can select a new schedule. Outcome: Built-in tasks: MoveTo, LookAt, Wait, Say, FireWeapon, PickUpProp, DropProp.

MATCHESSolution

CancellationTokenSource pattern allows cancelling mid-reload — In `OnReloadStart`. Tension: when switching weapons or firing. Outcome: cancel any existing reload, create a new CTS, set `isReloading = true`, then `await ReloadAsync(token)`.

MATCHESSolution

Cache schedules in a `Dictionary<Type, ScheduleBase>`. Tension: if `ActiveSchedule` is running, keep ticking it; otherwise call `GetSchedule()`. Outcome: Call `EndCurrentSchedule()` on damage to interrupt.

MATCHESSolution

Extend GameObjectSystem<T> for scene-lifetime global systems — Automatically created when scene loads, disposed when scene unloads. Tension: No GameObject needed — pure C# system. Outcome: Access from anywhere: var system = MyGameSystem.Current; // null if scene not loaded.

MATCHESSolution

Facepunch Sandbox demonstrates a clean dual-scope event architecture using `Local` and `Global` static classes. Tension: Difficulty implementing cancellable events.

MATCHESSolution

Record original scene objects on startup — CleanupSystem Component. Tension: Efficient batch destruction.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

Async Lifecycle Cancellation - inErrata Knowledge Graph | Inerrata