Global actors (@MainActor) in Swift - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to mark the function as running on the main actor.

Swift

@[1]
func updateUI() {
    print("UI updated")
}

Drag options to blanks, or click blank then click option'

AMainActor

BGlobalActor

CUIActor

DBackgroundActor

Attempts:

3 left

💡 Hint

Common Mistakes

Using @GlobalActor instead of @MainActor

Forgetting the '@' symbol before MainActor

Using unrelated actor names

The @MainActor attribute ensures the function runs on the main thread, which is important for UI updates.

2fill in blank

medium

Complete the code to declare a global actor named MyActor.

Swift

@globalActor
struct [1] {
    static let shared = MyActor()
}

Drag options to blanks, or click blank then click option'

AYourActor

BGlobalActor

CMainActor

DMyActor

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different name than the shared instance

Confusing with built-in actors like MainActor

The struct name must match the global actor name, here 'MyActor'.

3fill in blank

hard

Fix the error in the code to ensure the function runs on the main actor.

Swift

[1]
func updateData() async {
    print("Data updated")
}

Drag options to blanks, or click blank then click option'

A@MainActor

Basync

C@globalActor

D@UIActor

Attempts:

3 left

💡 Hint

Common Mistakes

Using @globalActor which is not a valid attribute

Placing async incorrectly

Using a non-existent actor like @UIActor

Adding @MainActor before the function ensures it runs on the main actor.

4fill in blank

hard

Fill both blanks to declare a global actor and use it on a function.

Swift

@globalActor
struct [1] {
    static let shared = [1]()
}

@[2]
func performTask() {
    print("Task performed")
}

Drag options to blanks, or click blank then click option'

ACustomActor

BMainActor

DGlobalActor

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for struct and shared instance

Using @MainActor instead of the custom actor

The struct name and shared instance must match, and the function uses the declared global actor attribute.

5fill in blank

hard

Fill all three blanks to create a global actor, mark a class with it, and declare an async function.

Swift

@globalActor
struct [1] {
    static let shared = [1]()
}

[2]
class DataManager {
    func fetchData() [3] {
        print("Fetching data")
    }
}

Drag options to blanks, or click blank then click option'

ANetworkActor

C@NetworkActor

Dasync

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting '@' before the actor name on the class

Mismatching struct and shared instance names

Omitting async keyword on the function

The struct and shared instance names must match, the class is marked with the global actor attribute, and the function is async.

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