Why Global actors (@MainActor) in Swift? - Purpose & Use Cases

The Big Idea

What if you could stop worrying about tricky thread bugs and let Swift handle UI updates safely for you?

The Scenario

Imagine you are building an app where many parts try to update the screen at the same time. Without a clear rule, these updates can clash, causing the app to freeze or show wrong information.

The Problem

Manually managing who updates the screen and when is slow and tricky. You might forget to protect some updates, leading to crashes or strange bugs that are hard to find.

The Solution

Using @MainActor tells Swift to run all marked code on the main thread safely. This means updates to the screen happen one at a time, without conflicts, making your app stable and smooth.

Before vs After

✗ Before

func updateUI() {
  DispatchQueue.main.async {
    // update UI here
  }
}

✓ After

@MainActor func updateUI() {
  // update UI here safely
}

What It Enables

It makes writing safe, clear code for the main thread easy, so your app stays responsive and bug-free.

Real Life Example

When a chat app receives new messages, @MainActor ensures the message list updates smoothly on the screen without glitches or crashes.

Key Takeaways

Manual thread management is error-prone and complex.

@MainActor automatically runs code on the main thread safely.

This leads to simpler, safer UI updates and better app stability.