[25] async / await

Question 1

What does async/await solve? async/await

Answer 1

Linear, structured async code — no callback pyramids.

Question 2

Mark an async function async/await

Answer 2

func fetchUser() async throws -> User { ... }

Question 3

Call an async function async/await

Answer 3

let user = try await fetchUser()

Question 4

What is a Task? async/await

Answer 4

A Task in Swift Concurrency allows you to call async methods inside a synchronous context. Take the following two methods:

func someSynchronousMethod() {
    Task {
        await someAsynchronousMethod()
    }
}

Question 5

Why would I want to keep a reference of a task?

Answer 5

A task runs regardless of whether you track it. However, without a reference, you can’t wait for its results or cancel its execution.

Question 6

Task cancellation basics async/await

Answer 6

Cooperative: check

Task.isCancelled // This can be useful if you don’t want the task to fail but return a default value instead.

or

try Task.checkCancellation(). // Throw and error if the task was already cancelled

Question 7

check if task was cancelled async / await

Answer 7

let task = Task {
    print("This is first")
    
    let sum = (1...100000).reduce(0, +)
    try Task.checkCancellation()
    print("This is second")
}

print("This is last")
task.cancel()

Output:
~~~

This is first
This is last
~~~

Question 8

What happens if a user cancels a task that have child tasks?

Answer 8

If a parent task is canceled, all of its child tasks are also automatically notified about the cancellation. Child tasks implicitly link to their parent, meaning their cancellation state links as well.

Question 9

What is a detached Task? async/await

Answer 9

A detached task in Swift Concurrency is an independent unit of async work that doesn’t inherit priority, actor context, or task-local values from its parent; you use it for fire-and-forget work that must run outside the caller’s context.

Question 10

Create a detached task async/await

Answer 10

let handle = Task.detached { await compute() }

Question 11

What are the risks of using detached tasks.

Answer 11

They won’t inherit the parent task’s priority and the task-local storage, and they won’t cancel if the parent task gets cancelled.

Question 12

Summary on Detached Tasks

Answer 12

Detached tasks should be your last resort. Most of the time, you won’t need them, and you’re able to solve the same using regular child tasks, async let, or task groups.

Question 13

What is async let? async/await

Answer 13

Declares a child task within the current scope that begins running immediately and can be awaited later, allowing structured concurrency.

Question 14

async let example async/await

Answer 14

async let a = fetchA()
async let b = fetchB()
let (ra, rb) = await (a, b)

Question 15

Why TaskGroup? async/await

Answer 15

Dynamically spawn many children and collect results.

Question 16

Throwing TaskGroup sample async/await

Answer 16

let r = try await withThrowingTaskGroup(of:Int.self){ g in
  for n in 1...10 {
	g.addTask { try await work(n) } 
 }
  var out:[Int]=[]
for try await x in g {
	out.append(x) 
	}
  return out
}

Question 17

What is an actor? async/await

Answer 17

Reference type with isolated mutable state; prevents data races.

Question 18

What is @MainActor? async/await

Answer 18

Enforces main-thread execution for UI-affecting code.

Question 19

@MainActor example async/await

Answer 19

@MainActor func updateUI(){
/* UIKit/SwiftUI */ 
}

Question 20

Define an actor async/await

Answer 20

actor Counter { var value=0; func inc(){ value+=1 } }

Question 21

Call actor from outside async/await

Answer 21

let c = Counter(); await c.inc()

Question 22

What is nonisolated? async/await

Answer 22

Access without hopping into actor (constants/pure funcs).

Question 23

nonisolated sample async/await

Answer 23

actor A { nonisolated let id = UUID() }

Question 24

What is Sendable? async/await

Answer 24

Type safe to pass across concurrency domains.

Question 25

Make type Sendable `async/await`

Answer 25

``` struct Safe: Sendable { let x:Int } ```

Question 26

Sleep in a task `async/await`

Answer 26

``` swift try await Task.sleep(nanoseconds: 500_000_000) ```

Question 27

AsyncSequence basics `async/await`

Answer 27

Produces values over time; consume with for await.

Question 28

Consume an AsyncSequence `async/await`

Answer 28

```swift for await line in socket.lines { print(line) } ```

Question 29

Bridge callbacks → async `async/await`

Answer 29

```swift func load() async throws -> Data { try await withCheckedThrowingContinuation { cont in api.load { cont.resume(with: $0) } } } ```

Question 30

Actors vs queues `async/await`

Answer 30

Prefer actors over manual locking/queues for Swift 5.9+.

Question 31

What is a global actor? `async/await`

Answer 31

Shared executor to serialize access across types.

Question 32

Define a global actor `async/await`

Answer 32

```swift @globalActor struct ModelActor: GlobalActor { static let shared = ModelActor() } ```

Question 33

Task priority `async/await`

Answer 33

Set on creation; maps to QoS.

Question 34

Priority example `async/await`

Answer 34

```swift Task(priority: .userInitiated) { await work() } ```

Question 35

Structured vs unstructured `async/await`

Answer 35

Structured tied to scope; unstructured Task{} is independent.

Question 36

Class isolation vs actor `async/await`

Answer 36

Classes aren’t isolated; guard with actors/locks/queues.

Question 37

Actor reentrancy `async/await`

Answer 37

Actors are reentrant; invariants must tolerate interleaving across awaits.

Question 38

@MainActor & SwiftUI `async/await`

Answer 38

Views run on main; mark model changes affecting UI as @MainActor.

Question 39

URLSession with await `async/await`

Answer 39

```swift let (data, _) = try await URLSession.shared.data(from: url) ```

Question 40

Migrate from GCD to async/await `async/await`

Answer 40

Prefer async/await; wrap legacy APIs with continuations; keep GCD for sources/interop.

Question 41

Common pitfall `async/await`

Answer 41

Forgetting await or calling async from sync—wrap in Task{} or make caller async.

Question 42

Testing async code `async/await`

Answer 42

Use async XCTest with await and expectations/for-await.