When you begin utilizing Swift Concurrency, actors will primarily change into your commonplace alternative for shielding mutable state. Nonetheless, introducing actors additionally tends to introduce extra concurrency than you meant which might result in extra advanced code, and a a lot more durable time transitioning to Swift 6 in the long term.
If you work together with state that’s protected by an actor, you need to to take action asynchronously. The result’s that you just’re writing asynchronous code in locations the place you may by no means have meant to introduce concurrency in any respect.
One strategy to resolve that’s to annotate your for instance view mannequin with the @MainActor annotation. This makes positive that every one your code runs on the principle actor, which implies that it is thread-safe by default, and it additionally makes positive that you may safely work together together with your mutable state.
That stated, this may not be what you are on the lookout for. You may wish to have code that does not run on the principle actor, that is not remoted by international actors or any actor in any respect, however you simply wish to have an old school thread-safe property.
Traditionally, there are a number of methods by which we will synchronize entry to properties. We used to make use of Dispatch Queues, for instance, when GCD was the usual for concurrency on Apple Platforms.
Lately, the Swift workforce added one thing known as a Mutex to Swift. With mutexes, now we have an alternative choice to actors for shielding our mutable state. I say various, however it’s probably not true. Actors have a really particular function in that they defend our mutable state for a concurrent atmosphere the place we would like code to be asynchronous. Mutexes, then again, are actually helpful once we don’t need our code to be asynchronous and when the operation we’re synchronizing is fast (like assigning to a property).
On this put up, we’ll discover use Mutex, when it is helpful, and the way you select between a Mutex or an actor.
Mutex utilization defined
A Mutex is used to guard state from concurrent entry. In most apps, there will likely be a handful of objects that could be accessed concurrently. For instance, a token supplier, an picture cache, and different networking-adjacent objects are sometimes accessed concurrently.
On this put up, I’ll use a quite simple Counter object to verify we don’t get misplaced in advanced particulars and specifics that don’t affect or change how we use a Mutex.
If you increment or decrement a counter, that’s a fast operation. And in a codebase the place. the counter is out there in a number of duties on the identical time, we would like these increment and decrement operations to be secure and free from information races.
Wrapping your counter in an actor is sensible from a idea standpoint as a result of we would like the counter to be protected against concurrent accesses. Nonetheless, once we do that, we make each interplay with our actor asynchronous.
To considerably stop this, we may constrain the counter to the principle actor, however that implies that we’re at all times going to must be on the principle actor to work together with our counter. We’d not at all times be on the identical actor once we work together with our counter, so we might nonetheless must await interactions in these conditions, and that is not preferrred.
In an effort to create a synchronous API that can also be thread-safe, we may fall again to GCD and have a serial DispatchQueue.
Alternatively, we will use a Mutex.
A Mutex is used to wrap a chunk of state and it ensures that there is unique entry to that state. A Mutex makes use of a lock below the hood and it comes with handy strategies to guarantee that we purchase and launch our lock rapidly and accurately.
Once we attempt to work together with the Mutex‘ state, now we have to attend for the lock to change into accessible. That is much like how an actor would work with the important thing distinction being that ready for a Mutex is a blocking operation (which is why we should always solely use it for fast and environment friendly operations).
Here is what interacting with a Mutex seems like:
class Counter {
non-public let mutex = Mutex(0)
func increment() {
mutex.withLock { depend in
depend += 1
}
}
func decrement() {
mutex.withLock { depend in
depend -= 1
}
}
}Our increment and decrement features each purchase the Mutex, and mutate the depend that’s handed to withLock.
Our Mutex is outlined by calling the Mutex initializer and passing it our preliminary state. On this case, we go it 0 as a result of that’s the beginning worth for our counter.
On this instance, I’ve outlined two features that safely mutate the Mutex‘ state. Now let’s see how we will get the Mutex‘ worth:
var depend: Int {
return mutex.withLock { depend in
return depend
}
}Discover that studying the Mutex worth can also be achieved withLock. The important thing distinction with increment and decrement right here is that as an alternative of mutating depend, I simply return it.
It’s completely important that we preserve our operations inside withLock brief. We don’t wish to maintain the lock for any longer than we completely must as a result of any threads which can be ready for our lock or blocked whereas we maintain the lock.
We will broaden our instance a little bit bit by including a get and set to our depend. This may enable customers of our Counter to work together with depend prefer it’s a traditional property whereas we nonetheless have data-race safety below the hood:
var depend: Int {
get {
return mutex.withLock { depend in
return depend
}
}
set {
mutex.withLock { depend in
depend = newValue
}
}
}We will now use our Counter as follows:
let counter = Counter()
counter.depend = 10
print(counter.depend)That’s fairly handy, proper?
Whereas we now have a sort that is freed from data-races, utilizing it in a context the place there are a number of isolation contexts is a little bit of a problem once we opt-in to Swift 6 since our Counter doesn’t conform to the Sendable protocol.
The great factor about Mutex and sendability is that mutexes are outlined as being Sendable in Swift itself. Because of this we will replace our Counter to be Sendable fairly simply, and with no need to make use of @unchecked Sendable!
closing class Counter: Sendable {
non-public let mutex = Mutex(0)
// ....
}At this level, now we have a fairly good setup; our Counter is Sendable, it’s freed from data-races, and it has a completely synchronous API!
Once we attempt to use our Counter to drive a SwiftUI view by making it @Observable, this get a little bit difficult:
struct ContentView: View {
@State non-public var counter = Counter()
var physique: some View {
VStack {
Textual content("(counter.depend)")
Button("Increment") {
counter.increment()
}
Button("Decrement") {
counter.decrement()
}
}
.padding()
}
}
@Observable
closing class Counter: Sendable {
non-public let mutex = Mutex(0)
var depend: Int {
get {
return mutex.withLock { depend in
return depend
}
}
set {
mutex.withLock { depend in
depend = newValue
}
}
}
}The code above will compile however the view received’t ever replace. That’s as a result of our computed property depend is predicated on state that’s not explicitly altering. The Mutex will change the worth it protects however that doesn’t change the Mutex itself.
In different phrases, we’re not mutating any information in a method that @Observable can “see”.
To make our computed property work @Observable, we have to manually inform Observable once we’re accessing or mutating (on this case, the depend keypath). Here is what that appears like:
var depend: Int {
get {
self.entry(keyPath: .depend)
return mutex.withLock { depend in
return depend
}
}
set {
self.withMutation(keyPath: .depend) {
mutex.withLock { depend in
depend = newValue
}
}
}
}By calling the entry and withMutation strategies that the @Observable macro provides to our Counter, we will inform the framework once we’re accessing and mutating state. This may tie into our Observable’s common state monitoring and it’ll enable our views to replace once we change our depend property.
Mutex or actor? The right way to resolve?
Selecting between a mutex and an actor shouldn’t be at all times trivial or apparent. Actors are actually good in concurrent environments when you have already got an entire bunch of asynchronous code. When you do not wish to introduce async code, or whenever you’re solely defending one or two properties, you are most likely within the territory the place a mutex makes extra sense as a result of the mutex is not going to pressure you to jot down asynchronous code anyplace.
I may faux that this can be a trivial resolution and it’s best to at all times use mutexes for easy operations like our counter and actors solely make sense whenever you wish to have an entire bunch of stuff working asynchronously, however the resolution often is not that simple.
By way of efficiency, actors and mutexes do not differ that a lot, so there’s not an enormous apparent efficiency profit that ought to make you lean in a single route or the opposite.
Ultimately, your alternative ought to be primarily based round comfort, consistency, and intent. In the event you’re discovering your self having to introduce a ton of async code simply to make use of an actor, you are most likely higher off utilizing a Mutex.
Actors ought to be thought-about an asynchronous software that ought to solely be utilized in locations the place you’re deliberately introducing and utilizing concurrency. They’re additionally extremely helpful whenever you’re making an attempt to wrap longer-running operations in a method that makes them thread-safe. Actors don’t block execution which implies that you’re utterly superb with having “slower” code on an actor.
When unsure, I wish to strive each for a bit after which I persist with the choice that’s most handy to work with (and infrequently that’s the Mutex…).
In Abstract
On this put up, you have realized about mutexes and the way you should utilize them to guard mutable state. I confirmed you ways they’re used, after they’re helpful, and the way a Mutex compares to an actor.
You additionally realized a little bit bit about how one can select between an actor or a property that is protected by a mutex.
Making a alternative between an actor or a Mutex is, for my part, not at all times straightforward however experimenting with each and seeing which model of your code comes out simpler to work with is an effective begin whenever you’re making an attempt to resolve between a Mutex and an actor.
