Learn iOS Development

Classes vs Actors in Swift

When to Use What

Photo by Vanesa Giaconi on Unsplash

Swift, Apple’s powerful and versatile programming language, offers developers two main choices for creating reference types: classes and actors. Both of these types allow you to model complex data structures and provide functionality, but they have different characteristics and use cases. In this blog, we’ll explore the differences between classes and actors in Swift and discuss when to use one over the other.

Classes in Swift

Classes in Swift are reference types, which means they are allocated on the heap and multiple variables can point to the same instance. Here are some key features of classes:

1. Shared State: Classes can be accessed and modified from multiple threads or tasks simultaneously. This makes them suitable for shared data structures and objects where concurrent access is required.
2. Inheritance: Classes support inheritance, enabling the creation of hierarchies of objects with shared behavior and properties. Subclasses can inherit and extend the functionality of their parent classes.
3. Performance Overhead: Due to the shared state, classes require careful management of thread safety, and this can introduce performance overhead. Developers must handle synchronization explicitly when working with shared data.
4. Reference Semantics: As reference types, classes are subject to reference counting and can lead to issues like retain cycles if not managed properly.

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

Actors in Swift

Actors, introduced in Swift 5.5, are a new reference type designed to simplify the management of shared state in concurrent programming. They offer the following features:

1. Isolated State: Actors enforce an isolated state, which means that their data cannot be accessed or modified by multiple threads concurrently. This eliminates the need for explicit synchronization and helps prevent data races.
2. Concurrency Support: Actors work seamlessly with Swift’s concurrency model, making them an excellent choice for building scalable and safe concurrent applications. They ensure that only one task can access their state at a time.
3. Data Protection: Actors protect their state, making it easier to reason about the behavior of your code. This improved safety makes it easier to write robust and reliable software.
4. Reference Semantics: Similar to classes, actors have reference semantics, but their state is isolated, which helps avoid many common concurrency issues.

actor BankAccount {
    private var balance: Double = 0.0

    func deposit(_ amount: Double) {
        balance += amount
    }

    func withdraw(_ amount: Double) {
        if balance >= amount {
            balance -= amount
        }
    }

    func getBalance() -> Double {
        return balance
    }
}

When to Use Classes

1. Inheritance and Subclassing: If you need to create a hierarchy of objects with shared behavior and properties, classes are the way to go. Use them when you want to create a base class and extend it with subclasses.
2. Performance Optimization: In situations where performance is critical and you’re confident about managing concurrency explicitly, classes may provide more control over shared state and synchronization.
3. Legacy Code: If you’re working with existing Objective-C code or integrating with Objective-C frameworks, classes are the natural choice as they are compatible with Objective-C.

When to Use Actors

1. Concurrency and Safety: If your application requires concurrent access to shared data while ensuring data integrity and preventing data races, actors are the preferred choice. They offer a more straightforward and safer approach to handling shared state.
2. New Projects: For new Swift projects, especially those that require concurrent programming, actors should be the default choice. They encourage safer coding practices and simplify the management of concurrency.
3. Isolated State: When you want to encapsulate data and protect it from external interference, actors provide a clear boundary between the actor and the outside world.
4. Async/Await: Actors are a natural fit for working with Swift’s async/await concurrency model. They help you write asynchronous code that is easy to reason about and free from data races.

Conclusion

In conclusion, the choice between classes and actors in Swift depends on the specific requirements of your project. Classes are more suitable for scenarios involving inheritance, explicit synchronization, and legacy code, while actors excel in situations that require isolation of state, concurrent access, and data protection. With the introduction of actors, Swift developers have a powerful tool to build safer and more reliable concurrent applications. Choose the right reference type based on your project’s needs to ensure the best balance of performance and safety.