Exploring concurrency adjustments in Swift 6.2 – Donny Wals

It is no secret that Swift concurrency might be fairly troublesome to study. There are plenty of ideas which can be completely different from what you are used to if you had been writing code in GCD. Apple acknowledged this in one among their imaginative and prescient paperwork they usually 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 may primarily change is the place code will run by default.

On this weblog put up, I would really like to try the 2 foremost options that may change how your Swift concurrency code works:

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

By the top of this put up you need to have a reasonably good sense of the impression that Swift 6.2 may have in your code, and the way you need to be transferring ahead till Swift 6.2 is formally accessible in a future Xcode launch.

Understanding nonisolated(nonsending)

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

For this put up, I’m utilizing an SPM package deal so my Package deal.swift accommodates the next:

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

I’m getting forward of myself although; let’s speak about what nonisolated(nonsending) is, what drawback 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

Once you write async capabilities in Swift 6.1 and earlier, you would possibly accomplish that on a category or struct as follows:

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

When loadUserPhotos 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 rationale for that is that loadUserPhotos is a nonisolated and async perform.

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("Whats up, world")
      .process { await getData() }
  }

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

Once you take a better take a look at the error, the compiler will clarify:

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

This error is similar to one that you simply’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’ll 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 operating in its personal isolation context. Since that perform has entry to self, it implies 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 accessing the identical object can result in information races if the article isn’t sendable.

The distinction between an async and non-async perform that’s nonisolated like loadUserPhotos is that the non-async perform would run on the caller’s actor. So if we name a nonisolated async perform from the primary actor then the perform will run on the primary actor. After we name a nonisolated async perform from a spot that’s not on the primary actor, then the referred to as perform 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 habits 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 referred to as nonisolated(nonsending). You don’t have to put in writing this manually; it’s the default so each nonisolated async perform shall be nonsending until you specify in any other case.

When a perform is nonisolated(nonsending) it implies that the perform gained’t cross actor boundaries. Or, in a extra sensible sense, a nonisolated(nonsending) perform 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 rationale for that’s that loadUserPhotos() would now be nonisolated(nonsending) by default, and it will run its perform physique on the primary actor as a substitute of operating it on the cooperative thread pool.

Let’s check out some examples, we could? 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 perform will obtain a nonisolated(nonsending) remedy by default, and it runs on the caller’s actor (if any). In different phrases, for those who name this perform on the primary actor it’ll run on the primary actor. Name it from a spot that’s not remoted to an actor; it’ll 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’ll at all times run on the primary actor, irrespective of the place it’s referred to 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’s going to 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’ll run there.

So what if we need to guarantee that our perform by no means runs on the primary actor? As a result of up to now, we’ve solely seen prospects that may both isolate loadUserPhotos to the primary actor, or choices that may inherit the callers actor.

Operating code away from any actors with @concurrent

Alongside nonisolated(nonsending), Swift 6.2 introduces the @concurrent key phrase. This key phrase will help you write capabilities that behave in the identical approach 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 perform as @concurrent, we guarantee that we at all times depart the caller’s actor and create our personal isolation context.

The @concurrent attribute ought to solely be utilized to capabilities which can be nonisolated. So for instance, including it to a technique on an actor gained’t work until 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()
  }
}

Be aware that on the time of writing each circumstances are allowed, and the @concurrent perform that’s not nonisolated acts prefer it’s not remoted at runtime. I count on that this can be a bug within the Swift 6.2 toolchain and that this can change because the 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 approach of working the place your nonisolated async capabilities inherit the caller’s actor as a substitute of at all times operating in their very own isolation context, but it surely does make for fewer compiler errors in observe, and it truly helps you do away with an entire bunch of foremost actor annotation based mostly on what I’ve been capable of attempt up to now.

I’m an enormous fan of decreasing the quantity of concurrency in my apps and solely introducing it once I need to explicitly accomplish that. Adopting this function helps rather a lot with that. Earlier than you go and mark all the pieces 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 operating all the pieces concurrently makes your code, and its execution rather a lot simpler to motive about within the large image.

That’s very true if 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 if you inform it to. This might be because 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 frequent resolution for fixing compiler errors and it’s most of the time the suitable factor to do.

Your code actually doesn’t have to do all the pieces asynchronously on a background thread.

Doing so is comparatively costly, typically doesn’t enhance efficiency, and it makes your code rather a lot more durable to motive about. You wouldn’t have written DispatchQueue.world() in every single place earlier than you adopted Swift Concurrency, proper? So why do the equal now?

Anyway, in Swift 6.2 we will make operating on the primary actor the default on a package deal degree. It is a function launched by SE-0466.

This implies which you could have UI packages and app targets and mannequin packages and so forth, robotically run code on the primary actor until you explicitly opt-out of operating on foremost with @concurrent or via your personal 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 present you possibly can both go MainActor.self as your default isolation to run all the pieces on foremost by default, or you should use nil to maintain the prevailing habits (or don’t go the setting in any respect to maintain the prevailing habits).

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

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

  // This perform will _always_ run on foremost 
  // if defaultIsolation is about to foremost actor
  func runMeSomewhere() async {
    MainActor.assertIsolated()
    // do some work, name async capabilities and so forth
  }
}

This code accommodates a nonisolated async perform. 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.

Possibly we simply wrote an async perform in order that we may 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 implies 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 need to add a perform 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 perform will run on the caller's actor
nonisolated func runMeSomewhere() async {
  MainActor.assertIsolated()
  // do some work, name async capabilities and so forth
}

And if we need to make sure that we’re by no means on the primary actor:

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

We have to opt-out of this foremost actor inference for each perform or property that we need to make nonisolated; we will’t do that for your complete sort.

In fact, your personal actors won’t instantly begin operating on the primary actor and kinds that you simply’ve annotated with your personal world actors aren’t impacted by this variation both.

Do you have to opt-in to defaultIsolation?

It is a robust query to reply. My preliminary thought is “sure”. For app targets, UI packages, and packages that primarily maintain view fashions I positively assume that going foremost actor by default is the suitable alternative.

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

The truth that total objects shall be made foremost actor by default looks like 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 feature present makes plenty of sense to me and I feel I’ll need to attempt it out for a bit earlier than making up my thoughts totally.