Actor / Preventing Data Races

// Defining an actor (similar syntax to a class)
actor ActorName {
    var state: Type

    init(initialValue: Type) {
        self.state = initialValue
    }

    // Methods inside an actor are automatically isolated
    func method() {
        state = newValue
    }
}

// Accessing an actor requires await
let result = await actorInstance.method()

// @MainActor: guarantees execution on the main thread
@MainActor
func updateUI() {
    // Update UI
}

import Foundation

// A thread-safe counter using an actor
actor Counter {
    private var count = 0

    func increment() {
        count += 1
    }

    func getCount() -> Int {
        return count
    }

    // nonisolated: a method that does not need actor isolation
    nonisolated func description() -> String {
        return "Counter actor"
    }
}

let counter = Counter()

// Increment 1000 times concurrently
await withTaskGroup(of: Void.self) { group in
    for _ in 1...1000 {
        group.addTask {
            await counter.increment()
        }
    }
}

let total = await counter.getCount()
print("Final count: \(total)")  // Always 1000

// nonisolated methods do not require await
print(counter.description())

// @MainActor: update the UI on the main thread
@MainActor
class ViewModel {
    var title: String = "Loading..."

    func loadData() async {
        // Process in the background
        let result = await Task.detached { "Data loaded" }.value
        // @MainActor allows direct UI updates
        title = result
        print("Title: \(title)")
    }
}

Task {
    let vm = await ViewModel()
    await vm.loadData()
}

With a regular class, accessing a property from multiple threads simultaneously can cause data races. Using an actor, access is automatically serialized, making it safe.

An actor is similar to a class but does not support inheritance. It can conform to protocols. From inside an actor, you can access its own properties and methods without await, but access from outside always requires await.

For the basics of async/await, see async / await basics.