Fucking Approachable Swift Concurrency

https://fuckingapproachableswiftconcurrency.com/zh-CN
Admin
A comprehensive and approachable guide to Swift Concurrency, covering async/await, Tasks, isolation,...
Tokens:9,899
Snippets:65
Trust Score:5.9
Update:9 months ago
Show doc for...
Tokens:
Raw
### Asynchronous Function with async/await in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Demonstrates how to define and call an asynchronous function using `async` and `await`. The `async` keyword marks a function that can suspend, and `await` pauses execution until the asynchronous call completes. This example fetches user data from a URL and decodes it, handling potential errors.

```swift
func fetchUser(id: Int) async throws -> User {
    let url = URL(string: "https://api.example.com/users/(id)")!
    let (data, _) = try await URLSession.shared.data(from: url)  // Suspend here
    return try JSONDecoder().decode(User.self, from: data)
}

// Calling it
let user = try await fetchUser(id: 123)
// Code here executes after fetchUser completes
```

--------------------------------

### Parallel Asynchronous Operations with async let in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Shows how to perform multiple asynchronous operations concurrently using `async let`. Instead of awaiting operations sequentially, `async let` allows them to start immediately, and `await` is used later to collect their results. This significantly improves performance when multiple independent asynchronous tasks need to be performed.

```swift
func loadProfile() async throws -> Profile {
    async let avatar = fetchImage("avatar.jpg")
    async let banner = fetchImage("banner.jpg")
    async let bio = fetchBio()

    // Fetching all three concurrently!
    return Profile(
        avatar: try await avatar,
        banner: try await banner,
        bio: try await bio
    )
}
```

--------------------------------

### Managing Asynchronous Work with Tasks in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Illustrates how to use `Task` to manage units of asynchronous work. Tasks allow you to start asynchronous operations from synchronous code and provide control over their execution, such as awaiting their results or canceling them. The `.task` modifier in SwiftUI is shown for lifecycle-aware task management.

```swift
struct ProfileView: View {
    @State private var avatar: Image?

    var body: some View {
        avatar
            .task { avatar = await downloadAvatar() }
    }
}

struct ProfileViewWithID: View {
    var userID: String
    @State private var avatar: Image?

    var body: some View {
        avatar
            .task(id: userID) { avatar = await downloadAvatar(for: userID) }
    }
}

Button("Save") {
    Task { await saveProfile() }
}
```

--------------------------------

### Measure Async Function Performance in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

A generic async function in Swift to measure the execution time of a given asynchronous block. It captures the start time, executes the block, and prints the duration. This function is initially nonisolated.

```swift
func measure<T>(
    _ label: String,
    block: () async throws -> T
) async rethrows -> T {
    let start = ContinuousClock.now
    let result = try await block()
    print("\(label): \(ContinuousClock.now - start)")
    return result
}
```

--------------------------------

### Data Race Example in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Illustrates a common data race scenario where multiple threads attempt to modify the same variable concurrently without proper synchronization. This code snippet shows two asynchronous operations incrementing a shared `count` variable, leading to undefined behavior, potential crashes, or incorrect results. This highlights the need for concurrency-safe mechanisms.

```swift
var count = 0

DispatchQueue.global().async { count += 1 }
DispatchQueue.global().async { count += 1 }

// Undefined behavior: crash, memory corruption, or wrong value
```

--------------------------------

### AI Agent Skill Integration for Swift Concurrency

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Provides command-line instructions for integrating Swift Concurrency knowledge into AI coding agents like Claude Code, Codex, Amp, and OpenCode. This allows AI agents to better understand and assist with asynchronous Swift code development.

```shell
# Personal Skills (All Projects)
mkdir -p ~/.claude/skills/swift-concurrency
curl -o ~/.claude/skills/swift-concurrency/SKILL.md https://fuckingapproachableswiftconcurrency.com/SKILL.md

# Project Skills (This Project Only)
mkdir -p .claude/skills/swift-concurrency
curl -o .claude/skills/swift-concurrency/SKILL.md https://fuckingapproachableswiftconcurrency.com/SKILL.md
```

```shell
# Global Instructions (All Projects)
curl -o ~/.codex/AGENTS.md https://fuckingapproachableswiftconcurrency.com/SKILL.md
# Project Instructions (This Project Only)
curl -o AGENTS.md https://fuckingapproachableswiftconcurrency.com/SKILL.md
```

```shell
# Project Instructions (Recommended)
curl -o AGENTS.md https://fuckingapproachableswiftconcurrency.com/SKILL.md
```

```shell
# Global Rules (All Projects)
mkdir -p ~/.config/opencode
curl -o ~/.config/opencode/AGENTS.md https://fuckingapproachableswiftconcurrency.com/SKILL.md
# Project Rules (This Project Only)
curl -o AGENTS.md https://fuckingapproachableswiftconcurrency.com/SKILL.md
```

--------------------------------

### Using TaskGroup for Managed Asynchronous Operations in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Demonstrates how to use `withThrowingTaskGroup` to manage and coordinate multiple asynchronous operations. The group collects results from all child tasks, returning when they complete, throw an error, or are cancelled. This approach provides control over subtasks, unlike unmanaged Tasks.

```swift
func doWork() async {

    // This will return when all child tasks have returned, thrown an error, or been cancelled
    let result = try await withThrowingTaskGroup() { group -> Int in
        group.addTask {
            try await self.performAsyncOperation1()
        }
        group.addTask {
            try await self.performAsyncOperation2()
        }

        var sum = 0
        // Wait and collect the results of the tasks here
        for try await result in group {
            sum += result
        }
        return sum
    }
    // The final result (sum) is available here
    print("Total sum: \(result)")
}

func performAsyncOperation1() async throws -> Int {
    // Simulate async work
    try await Task.sleep(nanoseconds: 1_000_000_000) // 1 second
    return 1
}

func performAsyncOperation2() async throws -> Int {
    // Simulate async work
    try await Task.sleep(nanoseconds: 500_000_000) // 0.5 seconds
    return 2
}
```

--------------------------------

### Define and Use an Actor in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Actors protect their mutable state by ensuring only one piece of code can access their data at a time. To interact with an actor from outside, you must use 'await'.

```swift
actor BankAccount {
    var balance: Double = 0

    func deposit(_ amount: Double) {
        balance += amount  // 安全:actor 保证独占访问
    }
}

// 从外部,你必须 await 来跨越边界
await account.deposit(100)
```

--------------------------------

### Accessing Task Results and Using TaskGroup in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Explains how to retrieve the result of a `Task` using `.value` and how to manage multiple concurrent child tasks using `TaskGroup`. `TaskGroup` is useful for parallel execution of several asynchronous operations, with benefits like cancellation propagation and error handling. The `withThrowingTaskGroup` function is demonstrated for managing tasks that can throw errors.

```swift
let handle = Task {
    return await fetchUserData()
}
let userData = await handle.value  // Pause until task completes

try await withThrowingTaskGroup(of: Void.self) { group in
    group.addTask { avatar = try await downloadAvatar(for: userID) }
    group.addTask { bio = try await fetchBio(for: userID) }
    group.addTask { stats = try await fetchStats(for: userID) }
    try await group.waitForAll()
}
```

--------------------------------

### Unnecessary MainActor.run Usage in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

This Swift code demonstrates an unnecessary use of `MainActor.run` to update UI after an asynchronous operation. A more idiomatic approach is to mark the function itself with `@MainActor` for clearer intent and better compiler assistance.

```swift
// Unnecessary
Task {
    let data = await fetchData()
    await MainActor.run {
        self.data = data
    }
}

// Better - directly make the function @MainActor
@MainActor
func loadData() async {
    self.data = await fetchData()
}
```

--------------------------------

### Explicit Actor Isolation for Async Functions in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

This Swift code shows how to explicitly manage actor isolation within a generic async function using the `isolation` parameter, defaulting to the current actor's isolation context. This allows the function to explicitly pass or inspect its isolation context.

```swift
func measure<T>(
    isolation: isolated (any Actor)? = #isolation,
    _ label: String,
    block: () async throws -> T
) async rethrows -> T {
    let start = ContinuousClock.now
    let result = try await block()
    print("\(label): \(ContinuousClock.now - start)")
    return result
}
```

--------------------------------

### MainActor Isolation in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Demonstrates the use of `@MainActor` to enforce isolation for a class, ensuring that its properties and methods can only be accessed from the main thread. This is crucial for UI-related code, as frameworks like SwiftUI, UIKit, and AppKit require main thread access. The compiler enforces these boundaries, preventing data races.

```swift
@MainActor
class ViewModel {
    var items: [Item] = []  // Protected by MainActor isolation
}
```

--------------------------------

### Explicitly Marking Concurrent Functions in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Use the '@concurrent' attribute to explicitly mark functions that should run on a background thread, typically for CPU-intensive work, opting out of the default MainActor isolation.

```swift
// 在 MainActor 上运行(默认)
func updateUI() async { }

// 在后台线程运行(显式选择)
@concurrent func processLargeFile() async { }
```

--------------------------------

### Accessing Nonisolated Actor Methods in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Marking code with 'nonisolated' allows it to be called from anywhere without 'await' and is safe as long as it doesn't access the actor's protected state.

```swift
actor BankAccount {
    var balance: Double = 0

    nonisolated func bankName() -> String {
        "Acme Bank"  // 没有访问 actor 状态,从任何地方调用都安全
    }
}

let name = account.bankName()  // 不需要 await
```

--------------------------------

### Tasks Inheriting Actor Isolation in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Tasks created with `Task { ... }` inherit the actor isolation from their creation context. This means the task will execute on the same actor as the code that spawned it, simplifying concurrency management for related operations.

```swift
@MainActor
class ViewModel {
    func doWork() {
        Task {
            // 继承 MainActor 隔离
            self.updateUI()  // 安全,不需要 await
        }
    }
}
```

--------------------------------

### SwiftUI's .task Modifier for View Lifecycle-Bound Async Operations

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Shows how to use the `.task(id:)` modifier in SwiftUI to perform asynchronous operations tied to a view's lifecycle. This modifier is ideal for launching async functions in response to UI interactions or state changes, ensuring the task is managed and cancelled when the view disappears.

```swift
import SwiftUI

struct ContentView: View {

    @State private var shouldLoadImage = false

    var body: some View {
        Button("Click Me!") {
            // Toggle the flag
            shouldLoadImage.toggle()
        }
        // View manages the child task
        // It starts before the view appears
        // And stops when the view disappears
        .task(id: shouldLoadImage) {
            // When the flag's value changes, SwiftUI restarts the task
            guard shouldLoadImage else { return }
            print("Loading image...")
            await loadImage()
            print("Image loaded.")
        }
    }

    func loadImage() async {
        // Simulate image loading
        try? await Task.sleep(nanoseconds: 2_000_000_000) // 2 seconds
    }
}
```

--------------------------------

### Detached Tasks in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Task.detached creates a task that does not inherit any actor isolation or context from its creator. This is useful for initiating background work that is completely independent, but it bypasses managed concurrency features like cancellation and return values.

```swift
@MainActor
class ViewModel {
    func doHeavyWork() {
        Task.detached {
            // 没有 actor 隔离,在协作池上运行
            let result = await self.expensiveCalculation()
            await MainActor.run {
                self.data = result  // 显式跳回来
            }
        }
    }
}
```

--------------------------------

### Closures Inheriting Actor Isolation in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Closures inherit the actor isolation from the context in which they are defined. This ensures that code within the closure executes with the same isolation as its surrounding scope, maintaining safety.

```swift
@MainActor
class ViewModel {
    func setup() {
        let closure = {
            // 从 ViewModel 继承 MainActor
            self.updateUI()  // 安全,相同隔离
        }
        closure()
    }
}
```

--------------------------------

### Defining Non-Sendable Classes in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Classes with mutable state are not Sendable by default because multiple contexts could modify the shared instance, leading to data races. Such types cannot be safely passed across isolation boundaries.

```swift
// Non-Sendable——它是带可变状态的类
class Counter {
    var count = 0  // 两个地方同时修改这个 = 灾难
}
```

--------------------------------

### Inheriting MainActor Isolation in Swift Functions

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Functions without explicit isolation attributes inherit the isolation of the caller. By default, with SWIFT_DEFAULT_ACTOR_ISOLATION set to MainActor, most functions will run on the MainActor.

```swift
@MainActor func updateUI() { }
func helper() { }
@concurrent func crunch() async { }
```

--------------------------------

### Making Classes Sendable in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

A class can conform to Sendable if it is 'final' and all its stored properties are immutable. For classes that guarantee thread safety through other means, '@unchecked Sendable' can be used, but requires careful manual verification.

```swift
final class APIConfig: Sendable {
    let baseURL: URL      // 不可变
    let timeout: Double   // 不可变
}

final class ThreadSafeCache: @unchecked Sendable {
    private let lock = NSLock()
    private var storage: [String: Data] = [: ]
}
```

--------------------------------

### Isolate Async Function to Caller's Executor in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

This Swift code demonstrates how to make a generic async function `nonisolated(nonsending)`. This ensures the function and its closure execute on the caller's actor, preventing data races by avoiding cross-isolation boundary communication.

```swift
nonisolated(nonsending)
func measure<T>(
    _ label: String,
    block: () async throws -> T
) async rethrows -> T {
    let start = ContinuousClock.now
    let result = try await block()
    print("\(label): \(ContinuousClock.now - start)")
    return result
}
```

--------------------------------

### Defining Sendable Value Types in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

Structs and enums are implicitly Sendable if all their properties are Sendable. This allows them to be safely passed across isolation boundaries, as each context receives a copy.

```swift
// Sendable——它是值类型,每个地方得到一份拷贝
struct User: Sendable {
    let id: Int
    let name: String
}
```

--------------------------------

### Blocking Main Thread with Async Function in Swift

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

This Swift code snippet illustrates a common mistake: performing synchronous, expensive calculations within an async function marked with `@MainActor`. This still blocks the main thread because `async` only means 'can be suspended', not 'runs on a background thread'.

```swift
// This still blocks main thread!
@MainActor
func slowFunction() async {
    let result = expensiveCalculation()  // Synchronous work = blocking
    data = result
}
```

--------------------------------

### Risk of Deadlock with Blocking Synchronous Calls in Swift Concurrency

Source: https://fuckingapproachableswiftconcurrency.com/zh-CN/index

This Swift code shows a dangerous pattern of blocking a cooperative thread pool using `DispatchSemaphore.wait()`. This can lead to deadlocks because the cooperative thread pool has a limited number of threads, and blocking them prevents other asynchronous tasks from running.

```swift
// Never do this - risk of deadlock
func badIdea() async {
    let semaphore = DispatchSemaphore(value: 0)
    Task {
        await doWork()
        semaphore.signal()
    }
    semaphore.wait()  // Blocks the cooperative thread!
}
```
Tokens:
Raw