mutex-actor.swift

import Synchronization
import SwiftUI

final class Counter1: Sendable {
  let count = Mutex(0)
  func increment() {
    count.withLock { $0 += 1 }
  }
  func increment10000() {
    for _ in 1...10_000 {
      increment()
    }
  }
}
final actor Counter2 {
  var count = 0
  func increment() {
    count += 1
  }
  func increment10000() {
    for _ in 1...10_000 {
      increment()
    }
  }
}

struct ContentView: View {
  var body: some View {
    Form {
      Button("Mutex") {
        let start = Date()
        defer { print("mutex", Date().timeIntervalSince(start).formatted()) }
        let counter = Counter1()
        counter.increment10000()
      }
      Button("Actor") {
        Task {
          let start = Date()
          defer { print("actor", Date().timeIntervalSince(start).formatted()) }
          let counter = Counter2()
          await counter.increment10000()
        }
      }
    }
  }
}

Have you tried putting the for loop in the Task? Big difference.

@seanwoodward that's not the point of this code snippet. This is showing that independently locking fields of a data type can lead to worse performance than using an actor.

@mbrandonw Do you find that still is the case? When I ran the code (on Mac), performance was very close for each.

Yes it generally is true, and it only becomes more true as the logic in the lock becomes more complex.