When you begin utilizing Swift Concurrency, actors will primarily turn into your normal selection for safeguarding mutable state. Nevertheless, introducing actors additionally tends to introduce extra concurrency than you meant which may result in extra advanced code, and a a lot more durable time transitioning to Swift 6 in the long term.
While 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 would possibly by no means have meant to introduce concurrency in any respect.
One method to resolve that’s to annotate your for instance view mannequin with the @MainActor annotation. This makes certain that every one your code runs on the principle actor, which implies that it is thread-safe by default, and it additionally makes certain that you could safely work together together with your mutable state.
That mentioned, this may not be what you are searching for. You would possibly wish to have code that does not run on the principle actor, that is not remoted by world 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 are able to synchronize entry to properties. We used to make use of Dispatch Queues, for instance, when GCD was the usual for concurrency on Apple Platforms.
Just lately, the Swift crew added one thing known as a Mutex to Swift. With mutexes, we now have an alternative choice to actors for safeguarding our mutable state. I say different, but it surely’s probably not true. Actors have a really particular function in that they shield our mutable state for a concurrent surroundings the place we would like code to be asynchronous. Mutexes, then again, are actually helpful after we don’t desire our code to be asynchronous and when the operation we’re synchronizing is fast (like assigning to a property).
On this submit, we’ll discover how you can 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 may be accessed concurrently. For instance, a token supplier, an picture cache, and different networking-adjacent objects are sometimes accessed concurrently.
On this submit, I’ll use a quite simple Counter object to verify we don’t get misplaced in advanced particulars and specifics that don’t influence or change how we use a Mutex.
While you increment or decrement a counter, that’s a fast operation. And in a codebase the place. the counter is accessible in a number of duties on the similar 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 viewpoint as a result of we would like the counter to be shielded from concurrent accesses. Nevertheless, after 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 would not at all times be on the identical actor after we work together with our counter, so we might nonetheless must await interactions in these conditions, and that is not superb.
So as to create a synchronous API that can also be thread-safe, we may fall again to GCD and have a serial DispatchQueue.
Alternatively, we are able to use a Mutex.
A Mutex is used to wrap a bit of state and it ensures that there is unique entry to that state. A Mutex makes use of a lock underneath the hood and it comes with handy strategies to be sure that we purchase and launch our lock rapidly and accurately.
After we attempt to work together with the Mutex‘ state, we now have to attend for the lock to turn into out there. That is just 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 must always solely use it for fast and environment friendly operations).
This is what interacting with a Mutex appears to be like like:
class Counter {
personal let mutex = Mutex(0)
func increment() {
mutex.withLock { rely in
rely += 1
}
}
func decrement() {
mutex.withLock { rely in
rely -= 1
}
}
}
Our increment and decrement capabilities each purchase the Mutex, and mutate the rely that’s handed to withLock.
Our Mutex is outlined by calling the Mutex initializer and passing it our preliminary state. On this case, we cross it 0 as a result of that’s the beginning worth for our counter.
On this instance, I’ve outlined two capabilities that safely mutate the Mutex‘ state. Now let’s see how we are able to get the Mutex‘ worth:
var rely: Int {
return mutex.withLock { rely in
return rely
}
}
Discover that studying the Mutex worth can also be performed withLock. The important thing distinction with increment and decrement right here is that as an alternative of mutating rely, I simply return it.
It’s completely important that we hold our operations inside withLock quick. 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 are able to increase our instance somewhat bit by including a get and set to our rely. This can permit customers of our Counter to work together with rely prefer it’s a standard property whereas we nonetheless have data-race safety underneath the hood:
var rely: Int {
get {
return mutex.withLock { rely in
return rely
}
}
set {
mutex.withLock { rely in
rely = newValue
}
}
}
We are able to now use our Counter as follows:
let counter = Counter()
counter.rely = 10
print(counter.rely)
That’s fairly handy, proper?
Whereas we now have a kind 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 after 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 are able to replace our Counter to be Sendable fairly simply, and without having to make use of @unchecked Sendable!
closing class Counter: Sendable {
personal let mutex = Mutex(0)
// ....
}
At this level, we now have a fairly good setup; our Counter is Sendable, it’s freed from data-races, and it has a completely synchronous API!
After we attempt to use our Counter to drive a SwiftUI view by making it @Observable, this get somewhat difficult:
struct ContentView: View {
@State personal var counter = Counter()
var physique: some View {
VStack {
Textual content("(counter.rely)")
Button("Increment") {
counter.increment()
}
Button("Decrement") {
counter.decrement()
}
}
.padding()
}
}
@Observable
closing class Counter: Sendable {
personal let mutex = Mutex(0)
var rely: Int {
get {
return mutex.withLock { rely in
return rely
}
}
set {
mutex.withLock { rely in
rely = newValue
}
}
}
}
The code above will compile however the view gained’t ever replace. That’s as a result of our computed property rely 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 after we’re accessing or mutating (on this case, the rely keypath). This is what that appears like:
var rely: Int {
get {
self.entry(keyPath: .rely)
return mutex.withLock { rely in
return rely
}
}
set {
self.withMutation(keyPath: .rely) {
mutex.withLock { rely in
rely = newValue
}
}
}
}
By calling the entry and withMutation strategies that the @Observable macro provides to our Counter, we are able to inform the framework after we’re accessing and mutating state. This can tie into our Observable’s common state monitoring and it’ll permit our views to replace after we change our rely property.
Mutex or actor? How you can determine?
Selecting between a mutex and an actor isn’t at all times trivial or apparent. Actors are actually good in concurrent environments when you have already got a complete bunch of asynchronous code. When you do not wish to introduce async code, or while you’re solely defending one or two properties, you are in all probability within the territory the place a mutex makes extra sense as a result of the mutex won’t power you to write down asynchronous code wherever.
I may fake that it is a trivial determination and you need to at all times use mutexes for easy operations like our counter and actors solely make sense while you wish to have a complete bunch of stuff working asynchronously, however the determination normally is not that simple.
When it comes to efficiency, actors and mutexes do not fluctuate that a lot, so there’s not an enormous apparent efficiency profit that ought to make you lean in a single path or the opposite.
In the long run, your selection ought to be based mostly round comfort, consistency, and intent. When you’re discovering your self having to introduce a ton of async code simply to make use of an actor, you are in all probability higher off utilizing a Mutex.
Actors ought to be thought of 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 while you’re attempting to wrap longer-running operations in a method that makes them thread-safe. Actors don’t block execution which implies that you’re utterly fantastic with having “slower” code on an actor.
When unsure, I wish to strive each for a bit after which I stick to the choice that’s most handy to work with (and infrequently that’s the Mutex…).
In Abstract
On this submit, you have realized about mutexes and the way you need to use them to guard mutable state. I confirmed you ways they’re used, once they’re helpful, and the way a Mutex compares to an actor.
You additionally realized somewhat bit about how one can select between an actor or a property that is protected by a mutex.
Making a selection between an actor or a Mutex is, for my part, not at all times simple however experimenting with each and seeing which model of your code comes out simpler to work with is an effective begin while you’re attempting to determine between a Mutex and an actor.
