TL;DR #

Actors are classes without inheritance, designed for concurrent code.

Intro #

Actors in Swift are a special kind of reference type designed to make concurrent (multithreaded) programming safer and easier by automatically protecting their internal state from being accessed simultaneously from multiple threads.

What Are Actors? #

• Thread Safety Built-In: Unlike classes, which are not inherently safe when accessed from different threads, actors ensure that only one task at a time can modify their internal state. This prevents data races (situations where multiple parts of your code try to change data at the same time).

• Concurrency Control: Actors manage access to their properties and methods, so you don’t need to write extra synchronization code (like locks) to ensure safety. Swift handles that for you behind the scenes.

Example #

Imagine you have a bank account that many parts of your program might want to update at once. With a regular class, you’d have to be very careful to avoid two updates happening at the same time. With an actor, this is automatically managed.

Using a Class (Not Thread-Safe by Default) #

class BankAccount {
    var balance: Int = 0

    func deposit(amount: Int) {
        balance += amount
    }
}

In the class example, if two threads call deposit(amount:) at the same time, you might run into issues where updates interfere with each other.

Using an Actor (Thread-Safe) #

actor BankAccount {
    var balance: Int = 0

    func deposit(amount: Int) {
        balance += amount
    }
}

With the actor version, Swift ensures that only one piece of code can access balance at a time. This means you can safely update your bank account from multiple concurrent tasks without worrying about conflicts.

Why Do We Need Actors When We Already Have Classes? #

• Automatic Concurrency Safety: Classes leave it up to you to manage access to shared data when using threads, which can lead to bugs if not handled properly. Actors automate this, reducing complexity and potential errors.

• Simpler Code: With actors, you don’t need to add extra code (like locks or queues) to protect data. The language handles it for you, letting you focus on writing your business logic.

• Improved Reliability: By preventing data races, actors help make your code more reliable, especially in applications where many parts of the program run concurrently (like in modern apps with lots of background work).

Classes vs Actors #

• Purpose: Classes are general-purpose objects, while Actors are designed for safe shared data.
• Concurrency Safety: Classes do not have built-in concurrency safety, whereas Actors provide automatic concurrency safety.
• Access Control: Classes allow direct access with no waiting, but Actors require the use of await.
• Inheritance: Classes support inheritance, but Actors do not.
• Use Case: Classes are broad and flexible, suitable for various purposes, while Actors are specifically tailored for concurrent tasks.
• Extra Tools Needed: Classes may require manual locks and queues for concurrency management, but Actors handle concurrency automatically, needing no extra tools.

Summary #

In summary, actors in Swift provide a safer and easier way to work with shared state in concurrent programs. They ensure that only one operation at a time can access their internal data, while classes leave that responsibility to the developer.