Exploring concurrency adjustments in Swift 6.2 – Donny Wals

It is no secret that Swift concurrency might be fairly tough to be taught. There are a number of ideas which are totally different from what you are used to while you have been writing code in GCD. Apple acknowledged this in certainly one of their imaginative and prescient paperwork and so they got down to make adjustments to how concurrency works in Swift 6.2. They don’t seem to be going to vary the basics of how issues work. What they are going to primarily change is the place code will run by default.

On this weblog submit, I would love to try the 2 foremost options that can change how your Swift concurrency code works:

1. The brand new nonisolated(nonsending) default function flag
2. Working code on the primary actor by default with the defaultIsolation setting

By the top of this submit it’s best to have a reasonably good sense of the impression that Swift 6.2 may have in your code, and the way you ought to be shifting ahead till Swift 6.2 is formally out there in a future Xcode launch.

Understanding nonisolated(nonsending)

The nonisolated(nonsending) function is launched by SE-0461 and it’s a reasonably large overhaul when it comes to how your code will work shifting ahead. On the time of scripting this, it’s gated behind an upcoming function compiler flag known as NonisolatedNonsendingByDefault. To allow this flag in your challenge, see this submit on leveraging upcoming options in an SPM package deal, or for those who’re seeking to allow the function in Xcode, check out enabling upcoming options in Xcode.

For this submit, I’m utilizing an SPM package deal so my Bundle.swift incorporates the next:

.executableTarget(
    title: "SwiftChanges",
    swiftSettings: [
        .enableExperimentalFeature("NonisolatedNonsendingByDefault")
    ]
)

I’m getting forward of myself although; let’s discuss what nonisolated(nonsending) is, what downside it solves, and the way it will change the way in which your code runs considerably.

Exploring the issue with nonisolated in Swift 6.1 and earlier

While you write async capabilities in Swift 6.1 and earlier, you would possibly achieve this on a category or struct as follows:

class NetworkingClient {
  func loadUserPhotos() async throws -> [Photo] {
    // ...
  }
}

When loadUserPhotos is known as, we all know that it’s going to not run on any actor. Or, in additional sensible phrases, we all know it’ll run away from the primary thread. The explanation for that is that loadUserPhotos is a nonisolated and async operate.

Because of this when you’ve gotten code as follows, the compiler will complain about sending a non-sendable occasion of NetworkingClient throughout actor boundaries:

struct SomeView: View {
  let community = NetworkingClient()

  var physique: some View {
    Textual content("Good day, world")
      .job { await getData() }
  }

  func getData() async {
    do {
      // sending 'self.community' dangers inflicting information races
      let pictures = attempt await community.loadUserPhotos()
    } catch {
      // ...
    }
  }
}

While you take a more in-depth take a look at the error, the compiler will clarify:

sending foremost actor-isolated ‘self.community’ to nonisolated occasion methodology ‘loadUserPhotos()’ dangers inflicting information races between nonisolated and foremost actor-isolated makes use of

This error is similar to one that you just’d get when sending a foremost actor remoted worth right into a sendable closure.

The issue with this code is that loadUserPhotos runs in its personal isolation context. Because of this it’s going to run concurrently with no matter the primary actor is doing.

Since our occasion of NetworkingClient is created and owned by the primary actor we will entry and mutate our networking occasion whereas loadUserPhotos is working in its personal isolation context. Since that operate has entry to self, it signifies that we will have two isolation contexts entry the identical occasion of NetworkingClient at the very same time.

And as we all know, a number of isolation contexts gaining access to the identical object can result in information races if the item isn’t sendable.

The distinction between an async and non-async operate that’s nonisolated like loadUserPhotos is that the non-async operate would run on the caller’s actor. So if we name a nonisolated async operate from the primary actor then the operate will run on the primary actor. Once we name a nonisolated async operate from a spot that’s not on the primary actor, then the known as operate will not run on the primary actor.

Swift 6.2 goals to repair this with a brand new default for nonisolated capabilities.

Understanding nonisolated(nonsending)

The conduct in Swift 6.1 and earlier is inconsistent and complicated for people, so in Swift 6.2, async capabilities will undertake a brand new default for nonisolated capabilities known as nonisolated(nonsending). You don’t have to jot down this manually; it’s the default so each nonisolated async operate might be nonsending except you specify in any other case.

When a operate is nonisolated(nonsending) it signifies that the operate received’t cross actor boundaries. Or, in a extra sensible sense, a nonisolated(nonsending) operate will run on the caller’s actor.

So once we opt-in to this function by enabling the NonisolatedNonsendingByDefault upcoming function, the code we wrote earlier is totally positive.

The explanation for that’s that loadUserPhotos() would now be nonisolated(nonsending) by default, and it will run its operate physique on the primary actor as a substitute of working it on the cooperative thread pool.

Let’s check out some examples, lets? We noticed the next instance earlier:

class NetworkingClient {
  func loadUserPhotos() async throws -> [Photo] {
    // ...
  }
}

On this case, loadUserPhotos is each nonisolated and async. Because of this the operate will obtain a nonisolated(nonsending) therapy by default, and it runs on the caller’s actor (if any). In different phrases, for those who name this operate on the primary actor it’s going to run on the primary actor. Name it from a spot that’s not remoted to an actor; it’s going to run away from the primary thread.

Alternatively, we would have added a @MainActor declaration to NetworkingClient:

@MainActor
class NetworkingClient {
  func loadUserPhotos() async throws -> [Photo] {
    return [Photo()]
  }
}

This makes loadUserPhotos remoted to the primary actor so it’s going to all the time run on the primary actor, regardless of the place it’s known as from.

Then we would even have the primary actor annotation together with nonisolated on loadUserPhotos:

@MainActor
class NetworkingClient {
  nonisolated func loadUserPhotos() async throws -> [Photo] {
    return [Photo()]
  }
}

On this case, the brand new default kicks in despite the fact that we didn’t write nonisolated(nonsending) ourselves. So, NetworkingClient is foremost actor remoted however loadUserPhotos will not be. It should inherit the caller’s actor. So, as soon as once more if we name loadUserPhotos from the primary actor, that’s the place we’ll run. If we name it from another place, it’s going to run there.

So what if we wish to guarantee that our operate by no means runs on the primary actor? As a result of to date, we’ve solely seen prospects that will both isolate loadUserPhotos to the primary actor, or choices that will inherit the callers actor.

Working code away from any actors with @concurrent

Alongside nonisolated(nonsending), Swift 6.2 introduces the @concurrent key phrase. This key phrase will mean you can write capabilities that behave in the identical method that your code in Swift 6.1 would have behaved:

@MainActor
class NetworkingClient {
  @concurrent
  nonisolated func loadUserPhotos() async throws -> [Photo] {
    return [Photo()]
  }
}

By marking our operate as @concurrent, we guarantee that we all the time depart the caller’s actor and create our personal isolation context.

The @concurrent attribute ought to solely be utilized to capabilities which are nonisolated. So for instance, including it to a way on an actor received’t work except the tactic is nonisolated:

actor SomeGenerator {
  // not allowed
  @concurrent
  func randomID() async throws -> UUID {
    return UUID()
  }

  // allowed
  @concurrent
  nonisolated func randomID() async throws -> UUID {
    return UUID()
  }
}

Observe that on the time of writing each circumstances are allowed, and the @concurrent operate that’s not nonisolated acts prefer it’s not remoted at runtime. I anticipate that it is a bug within the Swift 6.2 toolchain and that it will change for the reason that proposal is fairly clear about this.

How and when do you have to use NonisolatedNonSendingByDefault

In my view, opting in to this upcoming function is a good suggestion. It does open you as much as a brand new method of working the place your nonisolated async capabilities inherit the caller’s actor as a substitute of all the time working in their very own isolation context, but it surely does make for fewer compiler errors in follow, and it really helps you eliminate a complete bunch of foremost actor annotation based mostly on what I’ve been capable of attempt to date.

I’m a giant fan of lowering the quantity of concurrency in my apps and solely introducing it once I wish to explicitly achieve this. Adopting this function helps quite a bit with that. Earlier than you go and mark every thing in your app as @concurrent simply to make certain; ask your self whether or not you actually must. There’s most likely no want, and never working every thing concurrently makes your code, and its execution quite a bit simpler to cause about within the massive image.

That’s very true while you additionally undertake Swift 6.2’s second main function: defaultIsolation.

Exploring Swift 6.2’s defaultIsolation choices

In Swift 6.1 your code solely runs on the primary actor while you inform it to. This might be on account of a protocol being @MainActor annotated otherwise you explicitly marking your views, view fashions, and different objects as @MainActor.

Marking one thing as @MainActor is a reasonably widespread resolution for fixing compiler errors and it’s as a rule the precise factor to do.

Your code actually doesn’t must do every thing asynchronously on a background thread.

Doing so is comparatively costly, usually doesn’t enhance efficiency, and it makes your code quite a bit more durable to cause about. You wouldn’t have written DispatchQueue.international() all over the place earlier than you adopted Swift Concurrency, proper? So why do the equal now?

Anyway, in Swift 6.2 we will make working on the primary actor the default on a package deal stage. This can be a function launched by SE-0466.

This implies you can have UI packages and app targets and mannequin packages and many others, robotically run code on the primary actor except you explicitly opt-out of working on foremost with @concurrent or by way of your individual actors.

Allow this function by setting defaultIsolation in your swiftSettings or by passing it as a compiler argument:

swiftSettings: [
    .defaultIsolation(MainActor.self),
    .enableExperimentalFeature("NonisolatedNonsendingByDefault")
]

You don’t have to make use of defaultIsolation alongside NonisolatedNonsendingByDefault however I did like to make use of each choices in my experiments.

At the moment you possibly can both cross MainActor.self as your default isolation to run every thing on foremost by default, or you should use nil to maintain the present conduct (or don’t cross the setting in any respect to maintain the present conduct).

When you allow this function, Swift will infer each object to have an @MainActor annotation except you explicitly specify one thing else:

@Observable
class Individual {
  var myValue: Int = 0
  let obj = TestClass()

  // This operate will _always_ run on foremost 
  // if defaultIsolation is ready to foremost actor
  func runMeSomewhere() async {
    MainActor.assertIsolated()
    // do some work, name async capabilities and many others
  }
}

This code incorporates a nonisolated async operate. Because of this, by default, it will inherit the actor that we name runMeSomewhere from. If we name it from the primary actor that’s the place it runs. If we name it from one other actor or from no actor, it runs away from the primary actor.

This most likely wasn’t meant in any respect.

Perhaps we simply wrote an async operate in order that we might name different capabilities that wanted to be awaited. If runMeSomewhere doesn’t do any heavy processing, we most likely need Individual to be on the primary actor. It’s an observable class so it most likely drives our UI which signifies that just about all entry to this object needs to be on the primary actor anyway.

With defaultIsolation set to MainActor.self, our Individual will get an implicit @MainActor annotation so our Individual runs all its work on the primary actor.

Let’s say we wish to add a operate to Individual that’s not going to run on the primary actor. We will use nonisolated identical to we’d in any other case:

// This operate will run on the caller's actor
nonisolated func runMeSomewhere() async {
  MainActor.assertIsolated()
  // do some work, name async capabilities and many others
}

And if we wish to ensure we’re by no means on the primary actor:

// This operate will run on the caller's actor
@concurrent
nonisolated func runMeSomewhere() async {
  MainActor.assertIsolated()
  // do some work, name async capabilities and many others
}

We have to opt-out of this foremost actor inference for each operate or property that we wish to make nonisolated; we will’t do that for the whole kind.

After all, your individual actors won’t out of the blue begin working on the primary actor and kinds that you just’ve annotated with your individual international actors aren’t impacted by this variation both.

Do you have to opt-in to defaultIsolation?

This can be a robust query to reply. My preliminary thought is “sure”. For app targets, UI packages, and packages that primarily maintain view fashions I undoubtedly assume that going foremost actor by default is the precise selection.

You may nonetheless introduce concurrency the place wanted and will probably be far more intentional than it will have been in any other case.

The truth that whole objects might be made foremost actor by default looks as if one thing that would possibly trigger friction down the road however I really feel like including devoted async packages can be the way in which to go right here.

The motivation for this selection present makes a number of sense to me and I feel I’ll wish to attempt it out for a bit earlier than making up my thoughts totally.