MainActor for UI work in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using @MainActor?

Consider this Swift code snippet using @MainActor to update UI state. What will be printed?

Swift

import Foundation

@MainActor
class ViewModel {
    var count = 0

    func increment() {
        count += 1
        print("Count is now \(count)")
    }
}

let vm = ViewModel()
Task {
    await vm.increment()
}

A Count is now 1

B Count is now 0

C Compilation error due to missing @MainActor on Task

D Runtime error due to accessing count off main thread

💡 Hint

Remember @MainActor ensures code runs on the main thread for UI safety.

The @MainActor attribute on ViewModel means all its methods run on the main thread. Calling await vm.increment() inside Task correctly switches to main thread, so count increments and prints 1.

🧠 Conceptual

intermediate

Why use @MainActor for UI updates in Swift?

Which of these best explains why @MainActor is used for UI work in Swift concurrency?

A It automatically updates UI elements without explicit calls.

B It makes UI code run faster by using multiple threads.

C It disables concurrency for UI code to simplify logic.

D It guarantees UI code runs on the main thread to avoid race conditions and crashes.

💡 Hint

Think about thread safety and UI frameworks.

UI frameworks require updates on the main thread. @MainActor ensures code runs there, preventing crashes from concurrent access.

🔧 Debug

advanced

What error occurs with this code missing @MainActor?

This Swift code updates UI state without @MainActor. What error will it cause?

Swift

class ViewModel {
    var text = ""

    func updateText() {
        text = "Hello"
        print(text)
    }
}

let vm = ViewModel()
Task {
    vm.updateText()
}

A No error; code runs fine

B Compilation error: 'updateText' must be async

C Runtime warning about UI updates off main thread

D Deadlock because of missing await

💡 Hint

UI updates must happen on the main thread.

Without @MainActor, updateText runs on a background thread inside Task, causing runtime warnings or crashes due to UI updates off main thread.

📝 Syntax

advanced

Which option correctly applies @MainActor to a Swift function?

Choose the correct syntax to mark a Swift function to run on the main actor.

A @MainActor func updateUI() { print("UI updated") }

B func @MainActor updateUI() { print("UI updated") }

C func updateUI() { @MainActor print("UI updated") }

D func updateUI() @MainActor { print("UI updated") }

💡 Hint

Attributes come before the function keyword.

The correct syntax places @MainActor before the function declaration. Other options are invalid syntax.

🚀 Application

expert

How many times is the UI updated in this Swift code?

Given this Swift code using @MainActor and async calls, how many times will the UI update print statement run?

Swift

import Foundation

@MainActor
class UIHandler {
    var updates = 0

    func updateUI() {
        updates += 1
        print("UI updated \(updates) times")
    }
}

let handler = UIHandler()

Task {
    await handler.updateUI()
    Task {
        await handler.updateUI()
    }
    await handler.updateUI()
}

A 2 times

B 3 times

C 1 time

D 4 times

💡 Hint

Count each awaited call to updateUI inside the tasks.

There are three awaited calls to updateUI: one in the outer Task, one nested Task, and one more in the outer Task. Each increments and prints once.