Structured concurrency model in Swift - Step-by-Step Execution

Concept Flow - Structured concurrency model

Start Task

↓

Create Child Tasks

↓

Run Child Tasks Concurrently

↓

Wait for All Child Tasks

↓

Collect Results

↓

End Task

Structured concurrency runs child tasks inside a parent task, waits for all to finish, then continues.

Execution Sample

Swift

func fetchData() async -> String {
  async let a = fetchA()
  async let b = fetchB()
  return await a + b
}

Runs fetchA and fetchB concurrently, waits for both, then combines results.

Execution Table

Step	Action	Task State	Result/Output
1	Start fetchData()	Parent task started	No output yet
2	Create async let a = fetchA()	Child task A started	No output yet
3	Create async let b = fetchB()	Child task B started	No output yet
4	Run fetchA() concurrently	Child task A running	No output yet
5	Run fetchB() concurrently	Child task B running	No output yet
6	Await a and b results	Waiting for child tasks	No output yet
7	fetchA() completes	Child task A done	Result A ready
8	fetchB() completes	Child task B done	Result B ready
9	Combine results a + b	Parent task resumes	Combined result returned
10	fetchData() ends	Parent task done	Returns combined string

💡 All child tasks complete, parent task returns combined result.

Variable Tracker

Variable	Start	After Step 7	After Step 8	Final
a	Not started	Result A ready	Result A ready	Result A ready
b	Not started	Not ready	Result B ready	Result B ready
Combined Result	None	None	None	Result A + Result B

Key Moments - 3 Insights

Why do child tasks run concurrently instead of one after another?

Because async let starts child tasks immediately and runs them in parallel, as shown in steps 4 and 5.

When does the parent task wait for child tasks to finish?

At step 6, the parent uses await to pause until both child tasks complete, ensuring safe result collection.

What happens if one child task fails?

Structured concurrency cancels sibling tasks and propagates the error to the parent, maintaining task safety.

Visual Quiz - 3 Questions

Look at the execution table, at which step does the parent task wait for child tasks to finish?

A Step 8

B Step 3

C Step 6

D Step 10

💡 Hint

Check the 'Action' column for when 'Await a and b results' happens.

According to variable_tracker, what is the value of variable 'b' after step 7?

A Result B ready

B Not ready

C Result A ready

D None

💡 Hint

Look at the 'After Step 7' column for variable 'b' in variable_tracker.

If fetchB() took longer, which step would be delayed in the execution_table?

A Step 8

B Step 7

C Step 9

D Step 4

💡 Hint

Step 8 shows fetchB() completion; delay affects this step.

Concept Snapshot

Structured concurrency in Swift:
- Use async let to start child tasks concurrently.
- Parent task waits with await for all children.
- Ensures safe, predictable task lifetimes.
- Errors in children cancel siblings and propagate.
- Simplifies async code by structuring task hierarchy.

Full Transcript

Structured concurrency in Swift means running child tasks inside a parent task. The parent starts child tasks using async let, which runs them at the same time. Then the parent waits for all child tasks to finish using await. This way, the parent collects results safely and continues. If any child task fails, the others are canceled and the error goes to the parent. This model keeps async code organized and predictable.