Actors vs locks decision in Swift - When to Use Which

The Big Idea

What if you could avoid the chaos of managing locks and still keep your code safe and fast?

The Scenario

Imagine you have a busy kitchen where multiple chefs try to use the same knife at the same time. Without any rules, they bump into each other, causing delays and mistakes.

The Problem

Using manual locks to control access is like having one chef hold the knife and tell others to wait. It slows down the kitchen, can cause confusion if someone forgets to release the knife, and leads to errors or deadlocks.

The Solution

Actors in Swift act like individual chefs with their own knives. They manage their own tasks safely without needing to constantly check or wait for others, making the kitchen run smoothly and efficiently.

Before vs After

✗ Before

lock.lock()
// access shared resource
lock.unlock()

✓ After

actor MyActor {
  func doWork() async { /* safe code */ }
}

What It Enables

Actors let you write safe, concurrent code without the headache of managing locks manually.

Real Life Example

In a messaging app, actors can safely handle incoming messages one at a time, avoiding crashes or lost data without complex locking.

Key Takeaways

Manual locks are error-prone and slow down your program.

Actors provide a safer, cleaner way to handle concurrency.

Choosing actors over locks leads to more reliable and maintainable code.