메뉴
Add the Throttle mixin to prevent actions from running too frequently. Covers setting the throttle duration in milliseconds, use cases like price refresh, and how freshness/staleness works.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/marcglasberg/async_redux --skill asyncredux-throttle-mixin명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | asyncredux-throttle-mixin |
| description | Add the Throttle mixin to prevent actions from running too frequently. Covers setting the throttle duration in milliseconds, use cases like price refresh, and how freshness/staleness works. |
The Throttle mixin limits action execution to at most once per throttle period. When an action is dispatched multiple times within the defined window, only the first execution runs while subsequent calls abort silently. After the period expires, the next dispatch is permitted.
class LoadPrices extends AppAction with Throttle {
// Throttle period in milliseconds (default is 1000ms)
int get throttle => 5000; // 5 seconds
Future<AppState?> reduce() async {
var prices = await fetchCurrentPrices();
return state.copy(prices: prices);
}
}
The default throttle duration is 1000 milliseconds (1 second). Override the throttle getter to set a custom duration.
Throttle uses a "freshness window" concept:
This ensures that frequently triggered actions (like a "Refresh Prices" button) don't overwhelm your server while still allowing updates after a reasonable interval.
// User taps "Refresh" rapidly 5 times in 2 seconds
// With a 5-second throttle:
// - 1st tap: Action runs, prices update
// - 2nd-5th taps: Silently aborted (data still "fresh")
// - Tap after 5 seconds: Action runs again (data now "stale")
| Aspect | Throttle | Debounce |
|---|---|---|
| When it runs | Immediately on first dispatch | After dispatches stop |
| Blocking | Blocks for the period after running | Resets timer on each dispatch |
| Use case | Price refresh, rate-limited APIs | Search-as-you-type |
Override ignoreThrottle to conditionally skip rate limiting:
class LoadPrices extends AppAction with Throttle {
final bool forceRefresh;
LoadPrices({this.forceRefresh = false});
int get throttle => 5000;
// Bypass throttle when force refresh is requested
bool get ignoreThrottle => forceRefresh;
Future<AppState?> reduce() async {
var prices = await fetchCurrentPrices();
return state.copy(prices: prices);
}
}
// Normal dispatch - respects throttle
dispatch(LoadPrices());
// Force refresh - ignores throttle
dispatch(LoadPrices(forceRefresh: true));
By default, the throttle lock persists even after errors, preventing immediate retry:
class LoadPrices extends AppAction with Throttle {
int get throttle => 5000;
// Allow immediate retry if the action fails
bool get removeLockOnError => true;
Future<AppState?> reduce() async {
var prices = await fetchCurrentPrices();
return state.copy(prices: prices);
}
}
For more control, use these methods:
// Remove the lock for this specific action type
removeLock();
// Remove locks for all throttled actions
removeAllLocks();
Override lockBuilder() to implement different locking behaviors:
class LoadPricesForSymbol extends AppAction with Throttle {
final String symbol;
LoadPricesForSymbol(this.symbol);
int get throttle => 5000;
// Use the symbol as part of the lock key
// This allows throttling per symbol instead of per action type
Object lockBuilder() => 'LoadPrices_$symbol';
Future<AppState?> reduce() async {
var price = await fetchPrice(symbol);
return state.copy(prices: state.prices.add(symbol, price));
}
}
// These can run in parallel (different lock keys):
dispatch(LoadPricesForSymbol('AAPL'));
dispatch(LoadPricesForSymbol('GOOGL'));
// But this will be throttled (same lock key as first):
dispatch(LoadPricesForSymbol('AAPL')); // Aborted if within 5 seconds
class RefreshStockPrices extends AppAction with Throttle {
int get throttle => 10000; // At most once every 10 seconds
Future<AppState?> reduce() async {
var prices = await stockApi.getAllPrices();
return state.copy(stockPrices: prices);
}
}
class SyncWithServer extends AppAction with Throttle {
int get throttle => 30000; // At most once every 30 seconds
Future<AppState?> reduce() async {
var data = await api.sync();
return state.copy(lastSync: DateTime.now(), data: data);
}
}
class SubmitFeedback extends AppAction with Throttle {
final String feedback;
SubmitFeedback(this.feedback);
int get throttle => 60000; // At most once per minute
Future<AppState?> reduce() async {
await api.submitFeedback(feedback);
return state.copy(feedbackSubmitted: true);
}
}
Compatible with:
CheckInternetNoDialogAbortWhenNoInternetRetryUnlimitedRetriesDebounceIncompatible with:
NonReentrant (use one or the other, not both)OptimisticUpdateOptimisticSyncOptimisticSyncWithPushclass LoadPrices extends AppAction
with CheckInternet, Throttle, Retry {
int get throttle => 5000;
Future<AppState?> reduce() async {
// CheckInternet ensures connectivity
// Throttle prevents excessive calls
// Retry handles transient failures
var prices = await fetchCurrentPrices();
return state.copy(prices: prices);
}
}
URLs from the documentation: