How to Make Parts of an Actor Nonisolated in Swift

Understanding actor isolation is key to working effectively with Swift's concurrency model.

In Swift, actors are a powerful feature that ensures thread safety by isolating mutable state, making them ideal for protecting data from race conditions. However, there are times when you may want to allow nonisolated access to specific parts of an actor for efficiency or convenience.

In this blog, you'll learn how to use the Swift nonisolated keyword to achieve this and how to navigate the intricacies of actor isolation rules.

What Does Nonisolated Mean?

In Swift, nonisolated means that a property, method, or computed property within an actor is explicitly marked as accessible outside the actor's isolation. This allows synchronous access to those parts of the actor without requiring await.

Why Opt Out of Actor Isolation?

By default, actor isolation ensures that any access to an actor's mutable state is safe from data races. However, sometimes you need to opt out of this default behavior. For example:

• To expose constant properties that don't require synchronization.

• To conform to protocol requirements that demand synchronous access.

• To allow shared, thread-safe access to static or globally available data.

Actor Isolation: Default Behavior and Rules

Before diving into making parts of an actor nonisolated, let's recap some essential actor isolation rules:

1. Mutable state inside an actor is isolated and can only be accessed from within the actor's context.

2. Synchronous access to an actor's isolated properties or methods is disallowed from outside its isolation domain.

3. Immutable properties or global actors can simplify access to shared data safely.

Let’s explore how to apply the nonisolated keyword in practice.

How to Use the Nonisolated Keyword

The nonisolated keyword allows specific properties or methods of an actor to be accessed outside the actor's context. Here's how you can use it:

Example: Nonisolated Constant Property

Suppose you have an actor representing a bank account:

Copy
1actor BankAccount {
2    // By default, bankName and balance are part of the actor's isolated state.
3    let bankName: String
4    var balance: Double
5
6    init(bankName: String, initialBalance: Double) {
7        self.bankName = bankName
8        self.balance = initialBalance
9    }
10
11    func deposit(amount: Double) {
12        balance += amount
13    }
14}

By default, all properties and methods in BankAccount are isolated. If you need the bankName property to be accessible synchronously without isolation, you can mark it nonisolated:

Copy
1actor BankAccount {
2    nonisolated let bankName: String
3    var balance: Double
4
5    init(bankName: String, initialBalance: Double) {
6        self.bankName = bankName
7        self.balance = initialBalance
8    }
9
10    func deposit(amount: Double) {
11        balance += amount
12    }
13}

Now, you can access bankName from outside the actor without await:

Copy
1let account = BankAccount(bankName: "Swift Bank", initialBalance: 1000)
2print(account.bankName) // No 'await' required

Example: Nonisolated Method

Similarly, you can make methods nonisolated. For instance, if you have a method to log the account details that doesn't modify state:

Copy
1actor BankAccount {
2    nonisolated func printDetails() {
3        print("Bank: \(bankName), Balance: \(balance)")
4    }
5}

This method can now be called synchronously from outside the actor's isolation domain.

When to Avoid Nonisolated

Although nonisolated is useful, it comes with trade-offs. Misusing it can lead to race conditions or unsafe mutable state access. Avoid making a property or method nonisolated if:

• It interacts with or modifies the actor's mutable state.

• It requires guarantees about thread safety provided by actor isolation.

Advanced Use Cases

Nonisolated for Protocol Conformance

Protocols often require synchronous access to methods or properties of conforming types. By marking methods or properties nonisolated, you can fulfill such requirements while still using actors.

Copy
1protocol AccountHolder {
2    var name: String { get }
3}
4
5actor BankAccount: AccountHolder {
6    nonisolated let name: String
7
8    init(name: String) {
9        self.name = name
10    }
11}

Accessing Data Safely in a Nonisolated Context

When working with an actor's context, ensure that any nonisolated code does not compromise the actor's thread safety. For example, if you must access mutable state within a nonisolated context, use proper synchronization techniques like locks or semaphores.

Handling Computed Properties and Global Actors

You can also mark computed properties as nonisolated:

Copy
1actor BankAccount {
2    var balance: Double = 0.0
3
4    // Ensure balance is safely accessed if it is mutable.
5    nonisolated var stringBalance: String {
6        "Current balance: \(balance)"
7    }
8}

Using global actors like @MainActor can simplify mainactor-isolated code, allowing UI updates directly from the actor.

Understanding Swift Concurrency with Nonisolated

When dealing with Swift concurrency, keep in mind:

1. Actors are designed to isolate state by default.

2. Using nonisolated allows flexibility in accessing certain parts of the actor synchronously.

3. Carefully consider the impact on shared mutable state and avoid data races.

Final Notes

Mastering actor isolation and understanding when to use the nonisolated keyword can make your Swift code more efficient and maintainable. Whether you are exposing constant properties, meeting protocol conformance requirements, or ensuring efficient synchronous access, marking parts of an actor as nonisolated provides the flexibility you need without compromising thread safety.

Using these techniques, you can take full advantage of Swift's concurrency model while maintaining safe access to your actor's context. Remember, Swift nonisolated design choices should always balance convenience and safety in your application.