MainActor for UI updates in iOS Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when you update UI without MainActor?

Consider this Swift async function updating a UILabel text without @MainActor. What is the likely outcome?

iOS Swift

func updateLabel() async {
  label.text = "Hello"
}

A The label text updates but only after a delay of several seconds.

B The app may crash or show UI glitches due to thread violation.

C The UI updates smoothly without any issues.

D The code will not compile because label.text must be updated on MainActor.

💡 Hint

UI updates must happen on the main thread to avoid problems.

UIKit requires UI changes on the main thread. Without @MainActor, updates may happen on background threads causing crashes or glitches.

📝 Syntax

intermediate

Which function declaration correctly ensures UI updates on the main thread?

Select the correct Swift function declaration that guarantees UI updates run on the main thread using MainActor.

A

@MainActor func updateUI() async {
  label.text = "Hi"
}

B

func updateUI() @MainActor async {
  label.text = "Hi"
}

C

func updateUI() async @MainActor {
  label.text = "Hi"
}

D

func updateUI() async {
  label.text = "Hi"
}

💡 Hint

The @MainActor attribute goes before the func keyword or before the function name.

The correct syntax is to place @MainActor before the function declaration to ensure it runs on the main thread.

❓ lifecycle

advanced

Why use @MainActor on a ViewModel class for UI updates?

You have a ViewModel class that updates UI-bound properties. Why is marking the entire class with @MainActor beneficial?

A It forces all methods and properties to run on the main thread, preventing UI thread bugs.

B It makes the class run faster by using multiple threads.

C It disables concurrency features to simplify code.

D It automatically updates the UI without any code changes.

💡 Hint

UI updates must happen on the main thread to avoid crashes.

Marking the ViewModel with @MainActor ensures all its code runs on the main thread, preventing unsafe UI updates from background threads.

🔧 Debug

advanced

Identify the cause of a crash in this async UI update code

This Swift code crashes sometimes. What is the cause?

iOS Swift

func fetchData() async {
  let data = await loadData()
  label.text = data
}

func loadData() async -> String {
  // Simulate network delay
  try? await Task.sleep(nanoseconds: 1_000_000_000)
  return "Loaded"
}

A The label outlet is nil causing the crash.

B The Task.sleep call throws an error causing the crash.

C The await keyword is used incorrectly inside fetchData.

D Updating label.text off the main thread causes the crash.

💡 Hint

UI updates must happen on the main thread even after async calls.

After awaiting loadData(), the code continues on a background thread. Updating label.text there causes a crash.

🧠 Conceptual

expert

What does @MainActor guarantee in Swift concurrency?

Choose the best description of what @MainActor guarantees when applied to a function or class.

A @MainActor guarantees code runs on any thread but prioritizes the main thread.

B @MainActor guarantees that all code runs on the main thread synchronously.

C @MainActor guarantees that code runs on the main thread and serializes access to prevent data races.

D @MainActor guarantees code runs on a background thread to avoid blocking UI.

💡 Hint

Think about thread safety and UI updates.

@MainActor ensures code runs on the main thread and serializes access to avoid race conditions and unsafe UI updates.