marcglasberg/asyncredux-nonreentrant-mixin

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

1. Preventing duplicate form submissions - Stop users from accidentally submitting forms multiple times
2. Protecting API calls - Ensure save/update/delete operations don't fire concurrently
3. Resource-intensive tasks - Prevent expensive computations from running in parallel
4. 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:

• Throttle
• UnlimitedRetryCheckInternet
• Most optimistic update mixins (check the compatibility matrix)

References

URLs from the documentation:

• https://asyncredux.com/sitemap.xml
• https://asyncredux.com/flutter/advanced-actions/control-mixins
• https://asyncredux.com/flutter/advanced-actions/action-mixins
• https://asyncredux.com/flutter/advanced-actions/aborting-the-dispatch
• https://asyncredux.com/flutter/basics/dispatching-actions
• https://asyncredux.com/flutter/basics/async-actions