> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Swift Async Method
An asynchronous method in Swift is a function that can suspend its execution midway through its body, yielding control of the current thread back to the system. This cooperative multitasking mechanism allows the underlying thread to execute other tasks while the suspended method waits for an operation to complete, resuming execution once the awaited result is available.
## Syntax and Declaration
To declare an asynchronous method, append the `async` keyword to the method signature immediately after the parameter list and before the return arrow (`->`).
```swift theme={"dark"}
import Foundation
struct Resource {
// Resource properties
}
func processData(_ resource: Resource) async -> Data {
// Method body
return Data()
}
```
If the method can also throw errors, the `async` keyword must strictly precede the `throws` keyword.
```swift theme={"dark"}
func fetchResource() async throws -> Resource {
// Method body
return Resource()
}
```
## Suspension Points and the `await` Keyword
When an asynchronous method invokes another asynchronous operation, it must do so using the `await` keyword. This keyword designates a **potential suspension point**.
```swift theme={"dark"}
func executeWorkflow() async throws {
// Execution may suspend at the line below
let resource = try await fetchResource()
// Execution resumes here once fetchResource() completes.
// The result is assigned to '_' to explicitly discard it and prevent compiler warnings.
_ = await processData(resource)
}
```
At a suspension point:
1. The method pauses execution.
2. The method yields its thread to the Swift runtime's cooperative thread pool.
3. The thread is freed to execute other pending tasks.
4. When the awaited operation completes, the runtime schedules the suspended method for resumption.
*Note: Resumption does not guarantee execution on the exact same thread that initiated the suspension, unless the method is explicitly isolated to a specific executor (such as an `actor` or a global actor like `@MainActor`).*
## Calling Context
Because asynchronous methods require the ability to suspend, they cannot be invoked directly from synchronous code. They must be called from within an **asynchronous context**. This context is typically provided by:
* Another `async` method or function.
* A `Task` or `Task.detached` closure, which acts as a bridge from synchronous code into the asynchronous runtime.
```swift theme={"dark"}
// Synchronous function
func startWorkflow() {
// Bridging into an asynchronous context
Task {
do {
try await executeWorkflow()
} catch {
// Handle error
}
}
}
```
## Memory and State Management (Async Frames)
Unlike synchronous functions that maintain their state strictly on the thread's call stack, Swift implements asynchronous methods as **stackless coroutines**. When an `async` method suspends, the Swift compiler transforms the function into a state machine.
The method's current state—including local variables, arguments, and the instruction pointer—is stored in an **async frame**. Instead of relying on standard heap allocations for every suspension, these frames are managed by a highly optimized task-local allocator (often utilizing slab allocation). This architecture allows the thread's stack frame to be safely unwound and reused by other tasks. Upon resumption, the runtime restores the method's state from the async frame, allowing execution to proceed seamlessly from the exact point of suspension.
## Cooperative Cancellation
Swift's concurrency model relies on **cooperative cancellation**. An asynchronous method is not forcefully terminated by the runtime if its parent task is cancelled. Instead, the method is responsible for respecting task cancellation by periodically checking its cancellation state and halting execution appropriately.
This is achieved by either checking the `Task.isCancelled` boolean property or calling `try Task.checkCancellation()`, which throws a `CancellationError` if the task has been flagged for cancellation.
```swift theme={"dark"}
func processLargeDataset(_ dataset: [Resource]) async throws {
for chunk in dataset {
// Check for cancellation before processing the next chunk
try Task.checkCancellation()
_ = await processData(chunk)
}
}
```
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
