The fundamentals of structured concurrency in Swift defined – Donny Wals

Revealed on: March 17, 2023

Swift Concurrency closely depends on an idea referred to as Structured Concurrency to explain the connection between mum or dad and little one duties. It finds its foundation within the fork be a part of mannequin which is a mannequin that stems from the sixties.

On this submit, I’ll clarify what structured concurrency means, and the way it performs an essential position in Swift Concurrency.

Be aware that this submit will not be an introduction to utilizing the async and await key phrases in Swift. I’ve a lot of posts on the subject of Swift Concurrency that yow will discover proper right here. These posts all assist you to be taught particular bits and items of contemporary Concurrency in Swift. For instance, how you should utilize activity teams, actors, async sequences, and extra.

In the event you’re searching for a full introduction to Swift Concurrency, I like to recommend you take a look at my ebook. In my ebook I’m going in depth on all of the essential elements of Swift Concurrency that you could know so as to take advantage of out of contemporary concurrency options in Swift.

Anyway, again to structured concurrency. We’ll begin by wanting on the idea from a excessive degree earlier than just a few examples of Swift code that illustrates the ideas of structured concurrency properly.

Understanding the idea of structured concurrency

The ideas behind Swift’s structured concurrency are neither new nor distinctive. Certain, Swift implements some issues in its personal distinctive manner however the core concept of structured concurrency may be dated again all the way in which to the sixties within the type of the fork be a part of mannequin.

The fork be a part of mannequin describes how a program that performs a number of items of labor in parallel (fork) will await all work to finish, receiving the outcomes from every bit of labor (be a part of) earlier than persevering with to the subsequent piece of labor.

We will visualize the fork be a part of mannequin as follows:

Fork Join Model example

Within the graphic above you’ll be able to see that the primary activity kicks off three different duties. One in all these duties kicks off some sub-tasks of its personal. The unique activity can not full till it has acquired the outcomes from every of the duties it spawned. The identical applies to the sub-task that kicks of its personal sub-tasks.

You’ll be able to see that the 2 purple coloured duties should full earlier than the duty labelled as Activity 2 can full. As soon as Activity 2 is accomplished we will proceed with permitting Activity 1 to finish.

Swift Concurrency is closely primarily based on this mannequin but it surely expands on a number of the particulars slightly bit.

For instance, the fork be a part of mannequin doesn’t formally describe a manner for a program to make sure right execution at runtime whereas Swift does present these sorts of runtime checks. Swift additionally gives an in depth description of how error propagation works in a structured concurrency setting.

When any of the kid duties spawned in structured concurrency fails with an error, the mum or dad activity can determine to deal with that error and permit different little one duties to renew and full. Alternatively, a mum or dad activity can determine to cancel all little one duties and make the error the joined results of all little one duties.

In both situation, the mum or dad activity can not full whereas the kid duties are nonetheless operating. If there’s one factor you must perceive about structured concurrency that may be it. Structured concurrency’s predominant focus is describing how mum or dad and little one duties relate to one another, and the way a mum or dad activity cannot full when a number of of its little one duties are nonetheless operating.

So what does that translate to after we discover structured concurrency in Swift particularly? Let’s discover out!

Structured concurrency in motion

In its easiest and most simple type structured concurrency in Swift implies that you begin a activity, carry out some work, await some async calls, and finally your activity completes. This might look as follows:

func parseFiles() async throws -> [ParsedFile] {
  var parsedFiles = [ParsedFile]()

  for file in listing {
    let consequence = attempt await parseFile(file)

  return parsedFiles

The execution for our operate above is linear. We iterate over a listing of recordsdata, we await an asynchronous operate for every file within the listing, and we return an inventory of parsed recordsdata. We solely work on a single file at a time and at no level does this operate fork out into any parallel work.

We all know that sooner or later our parseFiles() operate was referred to as as a part of a Activity. This activity might be a part of a bunch of kid duties, it might be activity that was created with SwiftUI’s activity view modifier, it might be a activity that was created with Activity.indifferent. We actually don’t know. And it additionally doesn’t actually matter as a result of whatever the activity that this operate was referred to as from, this operate will at all times run the identical.

Nonetheless, we’re not seeing the ability of structured concurrency on this instance. The actual energy of structured concurrency comes after we introduce little one duties into the combination. Two methods to create little one duties in Swift Concurrency are to leverage async let or TaskGroup. I’ve detailed posts on each of those subjects so I gained’t go in depth on them on this submit:

Since async let has probably the most light-weight syntax of the 2, I’ll illustrate structured concurrency utilizing async let relatively than by a TaskGroup. Be aware that each strategies spawn little one duties which implies that they each adhere to the foundations from structured concurrency though there are variations within the issues that TaskGroup and async let clear up.

Think about that we’d prefer to implement some code that follows the fork be a part of mannequin graphic that I confirmed you earlier:

Fork Join Model example

We might write a operate that spawns three little one duties, after which one of many three little one duties spawns two little one duties of its personal.

The next code reveals what that appears like with async let. Be aware that I’ve omitted numerous particulars just like the implementation of sure lessons or features. The main points of those will not be related for this instance. The important thing info you’re searching for is how we will kick off a lot of work whereas Swift makes certain that each one work we kick off is accomplished earlier than we return from our buildDataStructure operate.

func buildDataStructure() async -> DataStructure {
  async let configurationsTask = loadConfigurations()
  async let restoredStateTask = loadState()
  async let userDataTask = fetchUserData()

  let config = await configurationsTask
  let state = await restoredStateTask
  let knowledge = await userDataTask

  return DataStructure(config, state, knowledge)

func loadConfigurations() async -> [Configuration] {
  async let localConfigTask = configProvider.native()
  async let remoteConfigTask = configProvider.distant()

  let (localConfig, remoteConfig) = await (localConfigTask, remoteConfigTask)

  return localConfig.apply(remoteConfig)

The code above implements the identical construction that’s outlined within the fork be a part of pattern picture.

We do every thing precisely as we’re purported to. All duties we create with async let are awaited earlier than the operate that we created them in returns. However what occurs after we overlook to await certainly one of these duties?

For instance, what if we write the next code?

func buildDataStructure() async -> DataStructure? {
  async let configurationsTask = loadConfigurations()
  async let restoredStateTask = loadState()
  async let userDataTask = fetchUserData()

  return nil

The code above will compile completely superb. You’ll see a warning about some unused properties however all in all of your code will compile and it’ll run simply superb.

The three async let properties which are created every signify a baby activity and as you understand every little one activity should full earlier than their mum or dad activity can full. On this case, that assure will likely be made by the buildDataStructure operate. As quickly as that operate returns it would cancel any operating little one duties. Every little one activity should then wrap up what they’re doing and honor this request for cancellation. Swift won’t ever abruptly cease executing a activity as a result of cancellation; cancellation is at all times cooperative in Swift.

As a result of cancellation is cooperative Swift is not going to solely cancel the operating little one duties, it would additionally implicitly await them. In different phrases, as a result of we don’t know whether or not cancellation will likely be honored instantly, the mum or dad activity will implicitly await the kid duties to guarantee that all little one duties are accomplished earlier than resuming.

How unstructured and indifferent duties relate to structured concurrency

Along with structured concurrency, we have now unstructured concurrency. Unstructured concurrency permits us to create duties which are created as stand alone islands of concurrency. They don’t have a mum or dad activity, and so they can outlive the duty that they have been created from. Therefore the time period unstructured. Once you create an unstructured activity, sure attributes from the supply activity are carried over. For instance, in case your supply activity is predominant actor certain then any unstructured duties created from that activity may even be predominant actor certain.

Equally in the event you create an unstructured activity from a activity that has activity native values, these values are inherited by your unstructured activity. The identical is true for activity priorities.

Nonetheless, as a result of an unstructured activity can outlive the duty that it bought created from, an unstructured activity is not going to be cancelled or accomplished when the supply activity is cancelled or accomplished.

An unstructured activity is created utilizing the default Activity initializer:

func spawnUnstructured() async {
  Activity {
    print("that is printed from an unstructured activity")

We will additionally create indifferent duties. These duties are each unstructured in addition to fully indifferent from the context that they have been created from. They don’t inherit any activity native values, they don’t inherit actor, and they don’t inherit precedence.

I cowl indifferent and unstructured duties extra in depth proper right here.

In Abstract

On this submit, you realized what structured concurrency means in Swift, and what its major rule is. You noticed that structured concurrency relies on a mannequin referred to as the fork be a part of mannequin which describes how duties can spawn different duties that run in parallel and the way all spawned duties should full earlier than the mum or dad activity can full.

This mannequin is actually highly effective and it gives plenty of readability and security round the way in which Swift Concurrency offers with mum or dad / little one duties which are created with both a activity group or an async let.

We explored structured concurrency in motion by writing a operate that leveraged numerous async let properties to spawn little one duties, and also you realized that Swift Concurrency gives runtime ensures round structured concurrency by implicitly awaiting any operating little one duties earlier than our mum or dad activity can full. In our instance this meant awaiting all async let properties earlier than coming back from our operate.

You additionally realized that we will create unstructured or indifferent duties with Activity.init and Activity.indifferent. I defined that each unstructured and indifferent duties are by no means little one duties of the context that they have been created in, however that unstructured duties do inherit some context from the context they have been created in.

All in all crucial factor to grasp about structured concurrency is that it present clear and inflexible guidelines across the relationship between mum or dad and little one duties. Particularly it describes how all little one duties should full earlier than a mum or dad activity can full.

Related Articles


Please enter your comment!
Please enter your name here

Latest Articles