Global actors (@MainActor) in Swift - Step-by-Step Execution

Concept Flow - Global actors (@MainActor)

Define @MainActor function

↓

Call function from main thread

↓

Function runs on main thread

↓

Update UI or shared resource safely

↓

Return control to caller

This flow shows how a function marked with @MainActor runs on the main thread to safely update UI or shared resources.

Execution Sample

Swift

import SwiftUI

@MainActor
func updateLabel() {
    print("Updating UI on main thread")
}

Task {
    await updateLabel()
}

This code defines a function marked with @MainActor and calls it asynchronously to ensure it runs on the main thread.

Execution Table

Step	Action	Thread	Result	Output
1	Define function updateLabel() with @MainActor	Main	Function ready
2	Start Task to call updateLabel()	Background	Task started
3	Await updateLabel() call	Background	Switch to main thread
4	Execute updateLabel() on main thread	Main	Print statement runs	Updating UI on main thread
5	Return from updateLabel()	Main	Function completes
6	Task completes	Background	Control returns

💡 Task finishes after updateLabel() runs on main thread and prints output

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
updateLabel()	Defined	Called (await)	Executed on main thread	Completed

Key Moments - 2 Insights

Why does updateLabel() run on the main thread even though Task starts on a background thread?

Because updateLabel() is marked with @MainActor, Swift automatically switches execution to the main thread before running it, as shown in step 3 and 4 of the execution_table.

What happens if we call updateLabel() without await inside Task?

You must use await to call an async @MainActor function; otherwise, the compiler will give an error. The await ensures the caller waits for the main thread switch, as seen in step 3.

Visual Quiz - 3 Questions

Look at the execution_table, on which step does the code switch to the main thread?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Check the 'Thread' column in execution_table row for step 3 showing 'Switch to main thread'

According to variable_tracker, what is the state of updateLabel() after step 4?

A Function is defined but not called

B Function is called but not executed

C Function executed on main thread

D Function completed and returned

💡 Hint

Look at variable_tracker row for updateLabel() after step 4

If we remove @MainActor from updateLabel(), what changes in the execution flow?

A Function runs on background thread without switching

B Function still runs on main thread automatically

C Function cannot be called from Task

D Function causes a compile error

💡 Hint

Without @MainActor, no automatic thread switch happens as shown in step 3 of execution_table

Concept Snapshot

@MainActor marks functions to run on the main thread.
Calls to @MainActor functions switch threads automatically.
Use await to call async @MainActor functions.
Ensures safe UI or shared resource updates.
Helps avoid threading bugs in Swift concurrency.

Full Transcript

This example shows a Swift function marked with @MainActor, which means it must run on the main thread. When we call this function inside a Task, which runs on a background thread, Swift automatically switches to the main thread before running the function. The execution_table traces each step: defining the function, starting the Task, switching threads, running the function, and completing the Task. The variable_tracker shows the function's state changes. Key moments clarify why the thread switch happens and the need for await. The visual quiz tests understanding of thread switching and function execution. Overall, @MainActor helps keep UI updates safe by running code on the main thread.