| name | asyncredux-nonreentrant-mixin |
| description | Add the NonReentrant mixin to prevent an action from dispatching while already in progress. Covers preventing duplicate form submissions, avoiding race conditions, and protecting long-running operations. |
NonReentrant Mixin
The NonReentrant mixin prevents concurrent execution of the same action type. When an action instance is already running, new dispatches of that same action are silently aborted.
Basic Usage
Add the NonReentrant mixin to any action that should not run concurrently:
class SaveAction extends AppAction with NonReentrant {
Future<AppState?> reduce() async {
await http.put('http://myapi.com/save', body: 'data');
return null;
}
}
With this mixin:
- If the user clicks "Save" multiple times rapidly, only the first dispatch executes
- Subsequent dispatches while the first is running are silently aborted
- No duplicate API calls or race conditions occur
How It Works
The NonReentrant mixin overrides the abortDispatch method. When abortDispatch() returns true, the action's before(), reduce(), and after() methods will not run, and the state stays unchanged.
By default, checks are based on the action's runtime type - multiple instances of the same action class cannot run simultaneously.
Common Use Cases
- Preventing duplicate form submissions - Stop users from accidentally submitting forms multiple times
- Protecting API calls - Ensure save/update/delete operations don't fire concurrently
- Resource-intensive tasks - Prevent expensive computations from running in parallel
- Avoiding race conditions - Ensure sequential execution of operations that must not overlap
Customization
Allow Different Parameters to Run Concurrently
Override nonReentrantKeyParams() to allow actions with different parameters to run in parallel:
class SaveItemAction extends AppAction with NonReentrant {
final String itemId;
SaveItemAction(this.itemId);
@override
Object? nonReentrantKeyParams() => itemId;
Future<AppState?> reduce() async {
await saveItem(itemId);
return null;
}
}
With this customization:
SaveItemAction('A') and SaveItemAction('B') can run concurrently- Two
SaveItemAction('A') dispatches will still block each other
Share Keys Across Different Action Types
Override computeNonReentrantKey() to make different action classes block each other:
class SaveUserAction extends AppAction with NonReentrant {
final String orderId;
SaveUserAction(this.orderId);
@override
Object? computeNonReentrantKey() => orderId;
Future<AppState?> reduce() async { ... }
}
class DeleteUserAction extends AppAction with NonReentrant {
final String orderId;
DeleteUserAction(this.orderId);
@override
Object? computeNonReentrantKey() => orderId;
Future<AppState?> reduce() async { ... }
}
This prevents SaveUserAction('123') and DeleteUserAction('123') from running simultaneously - useful when different operations on the same resource must not overlap.
Combining with Other Mixins
You can combine NonReentrant with other compatible mixins:
class LoadDataAction extends AppAction with CheckInternet, NonReentrant {
Future<AppState?> reduce() async {
final data = await fetchData();
return state.copy(data: data);
}
}
Incompatible mixins: NonReentrant cannot be combined with:
ThrottleUnlimitedRetryCheckInternet- Most optimistic update mixins (check the compatibility matrix)
References
URLs from the documentation:
