call<T> method
- Future<
T> function(), { - int priority = 0,
- Duration? timeout,
- RetryPolicy? retry,
- TaskTimeouts? timeouts,
Execute a function with concurrency limit
If the concurrency limit has not been reached, the function executes immediately. Otherwise, it is queued according to the queueStrategy.
priority is used when queueStrategy is QueueStrategy.priority.
Higher values execute first. Defaults to 0.
timeout if specified, the task will fail with TimeoutException
if it doesn't complete within the given duration. This is an alias for
timeouts.run and is kept for compatibility with earlier APIs.
The underlying operation isn't forcibly canceled, so the concurrency
slot remains occupied until that operation actually finishes.
timeouts provides queue/run/total timeout control. If timeouts.run is
specified, do not also pass timeout.
retry if specified, failed tasks will be retried according to the policy.
Returns a TaskHandle that can be used to cancel the task or await the result.
Example:
final handle = limit(() async {
return fetchData();
});
final result = await handle;
// With priority
await limit(() async => criticalTask(), priority: 10);
// With timeout
await limit(() async => slowTask(), timeout: Duration(seconds: 5));
// With retry
await limit(() async => unstableTask(), retry: RetryExponential(maxAttempts: 3, baseDelay: Duration(seconds: 1)));
// With fine-grained timeouts
await limit(
() async => fetchData(),
priority: 5,
timeouts: TaskTimeouts(
queue: Duration(seconds: 2),
run: Duration(seconds: 5),
total: Duration(seconds: 10),
),
);
Implementation
TaskHandle<T> call<T>(Future<T> Function() function,
{int priority = 0,
Duration? timeout,
RetryPolicy? retry,
TaskTimeouts? timeouts}) {
if (_isClosed) {
throw StateError('Cannot submit new tasks after FLimit has been closed.');
}
final resolved = _resolveTaskParameters(
priority: priority,
timeout: timeout,
retry: retry,
timeouts: timeouts,
);
final handle = TaskHandle<T>._(
_taskIdCounter++,
Completer<T>(),
_cancelQueuedTask,
);
_enqueue<T>(
() async => await function(),
handle,
priority: resolved.priority,
queueTimeout: resolved.queueTimeout,
runTimeout: resolved.runTimeout,
totalTimeout: resolved.totalTimeout,
retry: resolved.retry,
);
return handle;
}