Global actors (@MainActor) in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a @MainActor in Swift?

@MainActor is a global actor that ensures code runs on the main thread, which is important for updating the user interface safely.

beginner

Why should UI updates be done on the @MainActor?

Because UI frameworks require changes to happen on the main thread to avoid crashes or unexpected behavior.

beginner

How do you mark a Swift function to run on the main actor?

You add @MainActor before the function declaration, like @MainActor func updateUI() { ... }.

intermediate

What happens if you call a @MainActor function from a background thread?

Swift automatically switches execution to the main thread before running the function, ensuring thread safety.

intermediate

Can you mark an entire class as <code>@MainActor</code>? What does it mean?

<p>Yes, marking a class with <code>@MainActor</code> means all its methods and properties run on the main thread.</p>

What does @MainActor guarantee in Swift concurrency?

A Code runs on the main thread

B Code runs on a background thread

C Code runs in parallel on multiple threads

D Code runs only once

@MainActor ensures the code runs on the main thread, which is essential for UI updates.

How do you declare a function to run on the main actor?

A @MainActor func myFunction() {}

B func mainActor() {}

C func @MainActor myFunction() {}

D mainActor func myFunction() {}

You place @MainActor before the function declaration.

If you call a @MainActor method from a background thread, what happens?

A It runs immediately on the background thread

B It causes a crash

C Swift switches to the main thread before running it

D It runs on a random thread

Swift automatically switches to the main thread to run @MainActor code safely.

Which of these can be marked with @MainActor?

A Only functions

B Only structs

C Only variables

D Functions, classes, and properties

You can mark functions, classes, and properties with @MainActor to run them on the main thread.

Why is it important to use @MainActor for UI code?

A To improve performance

B To avoid UI glitches and crashes

C To run code faster

D To use less memory

UI frameworks require updates on the main thread to avoid glitches and crashes.

Explain what @MainActor does and why it is important in Swift concurrency.

Think about where UI updates must happen.

Describe how you would use @MainActor to protect a class that updates the user interface.

Consider marking the whole class instead of individual methods.

Practice

1. What is the main purpose of using @MainActor in Swift?

easy

A. To create background tasks without blocking the UI

B. To make code run faster by using multiple threads

C. To encrypt data automatically

D. To ensure code runs on the main thread for UI safety

Solution

1. Step 1: Understand the role of @MainActor

   @MainActor marks code to run on the main thread, which is important for UI updates.

2. Step 2: Compare options with this purpose

   Only To ensure code runs on the main thread for UI safety correctly states that @MainActor ensures code runs on the main thread for UI safety.

3. Final Answer:

   To ensure code runs on the main thread for UI safety -> Option D

4. Quick Check:

   @MainActor purpose = UI safety on main thread [OK]

Hint: Remember: @MainActor means run on main thread for UI [OK]

Common Mistakes:

• Thinking @MainActor speeds up code
• Confusing @MainActor with background threading
• Assuming @MainActor encrypts data

2. Which of the following is the correct way to declare a function that runs on the main actor?

easy

A. @MainActor func updateUI() { }

B. func @MainActor updateUI() { }

C. func updateUI() @MainActor { }

D. func updateUI() mainActor { }

Solution

1. Step 1: Recall correct syntax for @MainActor

   The attribute @MainActor is placed before the function declaration.

2. Step 2: Check each option's syntax

   @MainActor func updateUI() { } correctly places @MainActor before the function name. Others have incorrect placement or syntax.

3. Final Answer:

   @MainActor func updateUI() { } -> Option A

4. Quick Check:

   @MainActor syntax = before func [OK]

Hint: Put @MainActor right before func keyword [OK]

Common Mistakes:

• Placing @MainActor after function name
• Using invalid keywords like mainActor without @
• Inserting @MainActor inside function parentheses

3. Consider this Swift code snippet:

@MainActor
class ViewModel {
    func update() {
        print("Updated on main thread")
    }
}

func backgroundTask() async {
    let vm = await ViewModel()
    await vm.update()
}

Task {
    await backgroundTask()
}

What will be printed when this code runs?

medium

A. No output due to error

B. Updated on main thread

C. Updated on background thread

D. Runtime crash due to thread violation

Solution

1. Step 1: Understand @MainActor on ViewModel class

   The entire ViewModel class runs on the main thread because of @MainActor.

2. Step 2: Analyze the call to update() with await

   Calling await vm.update() from backgroundTask correctly switches to main thread and runs update(), printing the message.

3. Final Answer:

   Updated on main thread -> Option B

4. Quick Check:

   @MainActor enforces main thread execution [OK]

Hint: await switches to main thread for @MainActor code [OK]

Common Mistakes:

• Expecting no output due to async
• Thinking update runs on background thread
• Assuming thread violation crash

4. This code produces a compile error. What is the mistake?

class DataManager {
    @MainActor func save() {
        print("Saving data")
    }
}

func run() {
    let dm = DataManager()
    dm.save()
}

medium

A. Cannot use @MainActor on class methods

B. Function save() must be static

C. Missing await when calling @MainActor async function

D. DataManager must be marked @MainActor

Solution

1. Step 1: Identify @MainActor function requirements

   Functions marked @MainActor are asynchronous and must be called with await.

2. Step 2: Check call to save()

   Calling dm.save() without await causes a compile error because save() is async under @MainActor.

3. Final Answer:

   Missing await when calling @MainActor async function -> Option C

4. Quick Check:

   @MainActor functions require await calls [OK]

Hint: Always use await when calling @MainActor functions [OK]

Common Mistakes:

• Calling @MainActor functions without await
• Thinking @MainActor disallows methods on classes
• Believing @MainActor requires static functions

5. You want to create a Swift class that updates UI labels safely from any thread. Which is the best way to ensure all UI updates happen on the main thread using @MainActor?

hard

A. Mark the class with @MainActor and call its methods with await from any thread

B. Mark each UI label property with @MainActor individually

C. Use DispatchQueue.global() inside the class methods

D. Mark the class as final and use synchronous methods only

Solution

1. Step 1: Understand @MainActor usage for UI safety

   Marking the whole class with @MainActor ensures all its code runs on the main thread.

2. Step 2: Consider calling methods with await

   Calling methods with await from any thread safely switches to main thread for UI updates.

3. Step 3: Evaluate other options

   Marking individual properties is less effective; DispatchQueue.global() runs on background thread; final keyword does not ensure thread safety.

4. Final Answer:

   Mark the class with @MainActor and call its methods with await from any thread -> Option A

5. Quick Check:

   @MainActor class + await calls = safe UI updates [OK]

Hint: Use @MainActor on class and await calls for UI safety [OK]

Common Mistakes:

• Marking only properties instead of class
• Using background queues for UI updates
• Ignoring async/await with @MainActor