Swift structured concurrency tutorial – The.Swift.Dev.

Introducing structured concurrency in Swift

In my earlier tutorial we have talked about the brand new async/await characteristic in Swift, after that I’ve created a weblog publish about thread secure concurrency utilizing actors, now it’s time to get began with the opposite main concurrency characteristic in Swift, referred to as structured concurrency. 🔀

What’s structured concurrency? Effectively, lengthy story brief, it is a new task-based mechanism that enables builders to carry out particular person process objects in concurrently. Usually once you await for some piece of code you create a possible suspension level. If we take our quantity calculation instance from the async/await article, we might write one thing like this:

let x = await calculateFirstNumber()
let y = await calculateSecondNumber()
let z = await calculateThirdNumber()
print(x + y + z)

I’ve already talked about that every line is being executed after the earlier line finishes its job. We create three potential suspension factors and we await till the CPU has sufficient capability to execute & end every process. This all occurs in a serial order, however generally this isn’t the conduct that you really want.

If a calculation will depend on the results of the earlier one, this instance is ideal, since you should utilize x to calculate y, or x & y to calculate z. What if we would wish to run these duties in parallel and we do not care the person outcomes, however we want all of them (x,y,z) as quick as we will? 🤔

async let x = calculateFirstNumber()
async let y = calculateSecondNumber()
async let z = calculateThirdNumber()

let res = await x + y + z
print(res)

I already confirmed you ways to do that utilizing the async let bindings proposal, which is a sort of a excessive stage abstraction layer on prime of the structured concurrency characteristic. It makes ridiculously straightforward to run async duties in parallel. So the large distinction right here is that we will run the entire calculations directly and we will await for the outcome “group” that comprises each x, y and z.

Once more, within the first instance the execution order is the next:

• await for x, when it’s prepared we transfer ahead
• await for y, when it’s prepared we transfer ahead
• await for z, when it’s prepared we transfer ahead
• sum the already calculated x, y, z numbers and print the outcome

We might describe the second instance like this

• Create an async process merchandise for calculating x
• Create an async process merchandise for calculating y
• Create an async process merchandise for calculating z
• Group x, y, z process objects collectively, and await sum the outcomes when they’re prepared
• print the ultimate outcome

As you’ll be able to see this time we do not have to attend till a earlier process merchandise is prepared, however we will execute all of them in parallel, as an alternative of the common sequential order. We nonetheless have 3 potential suspension factors, however the execution order is what actually issues right here. By executing duties parallel the second model of our code will be method quicker, for the reason that CPU can run all of the duties directly (if it has free employee thread / executor). 🧵

At a really primary stage, that is what structured concurrency is all about. In fact the async let bindings are hiding a lot of the underlying implementation particulars on this case, so let’s transfer a bit right down to the rabbit gap and refactor our code utilizing duties and process teams.

await withTaskGroup(of: Int.self) { group in
    group.async {
        await calculateFirstNumber()
    }
    group.async {
        await calculateSecondNumber()
    }
    group.async {
        await calculateThirdNumber()
    }

    var sum: Int = 0
    for await res in group {
        sum += res
    }
    print(sum)
}

Based on the present model of the proposal, we will use duties as primary items to carry out some form of work. A process will be in considered one of three states: suspended, working or accomplished. Activity additionally help cancellation they usually can have an related precedence.

Duties can type a hierarchy by defining little one duties. At present we will create process teams and outline little one objects by way of the group.async perform for parallel execution, this little one process creation course of will be simplified through async let bindings. Kids mechanically inherit their dad or mum duties’s attributes, equivalent to precedence, task-local storage, deadlines and they are going to be mechanically cancelled if the dad or mum is cancelled. Deadline help is coming in a later Swift launch, so I will not discuss extra about them.

A process execution interval is known as a job, every job is working on an executor. An executor is a service which may settle for jobs and arranges them (by precedence) for execution on obtainable thread. Executors are at the moment offered by the system, however afterward actors will be capable of outline customized ones.

That is sufficient idea, as you’ll be able to see it’s potential to outline a process group utilizing the withTaskGroup or the withThrowingTaskGroup strategies. The one distinction is that the later one is a throwing variant, so you’ll be able to attempt to await async capabilities to finish. ✅

A process group wants a ChildTaskResult sort as a primary parameter, which must be a Sendable sort. In our case an Int sort is an ideal candidate, since we’ll accumulate the outcomes utilizing the group. You possibly can add async process objects to the group that returns with the right outcome sort.

We will collect particular person outcomes from the group by awaiting for the the following component (await group.subsequent()), however for the reason that group conforms to the AsyncSequence protocol we will iterate by way of the outcomes by awaiting for them utilizing a typical for loop. 🔁

That is how structured concurrency works in a nutshell. The very best factor about this complete mannequin is that by utilizing process hierarchies no little one process will likely be ever in a position to leak and hold working within the background accidentally. This a core cause for these APIs that they need to at all times await earlier than the scope ends. (thanks for the strategies @ktosopl). ❤️

Let me present you a number of extra examples…

Ready for dependencies

When you’ve got an async dependency to your process objects, you’ll be able to both calculate the outcome upfront, earlier than you outline your process group or inside a gaggle operation you’ll be able to name a number of issues too.

import Basis

func calculateFirstNumber() async -> Int {
    await withCheckedContinuation { c in
        DispatchQueue.essential.asyncAfter(deadline: .now() + 2) {
            c.resume(with: .success(42))
        }
    }
}

func calculateSecondNumber() async -> Int {
    await withCheckedContinuation { c in
        DispatchQueue.essential.asyncAfter(deadline: .now() + 1) {
            c.resume(with: .success(6))
        }
    }
}

func calculateThirdNumber(_ enter: Int) async -> Int {
    await withCheckedContinuation { c in
        DispatchQueue.essential.asyncAfter(deadline: .now() + 4) {
            c.resume(with: .success(9 + enter))
        }
    }
}

func calculateFourthNumber(_ enter: Int) async -> Int {
    await withCheckedContinuation { c in
        DispatchQueue.essential.asyncAfter(deadline: .now() + 3) {
            c.resume(with: .success(69 + enter))
        }
    }
}

@essential
struct MyProgram {
    
    static func essential() async {

        let x = await calculateFirstNumber()
        await withTaskGroup(of: Int.self) { group in
            group.async {
                await calculateThirdNumber(x)
            }
            group.async {
                let y = await calculateSecondNumber()
                return await calculateFourthNumber(y)
            }
            

            var outcome: Int = 0
            for await res in group {
                outcome += res
            }
            print(outcome)
        }
    }
}

It’s value to say that if you wish to help a correct cancellation logic you ought to be cautious with suspension factors. This time I will not get into the cancellation particulars, however I will write a devoted article concerning the matter in some unspecified time in the future in time (I am nonetheless studying this too… 😅).

Duties with totally different outcome sorts

In case your process objects have totally different return sorts, you’ll be able to simply create a brand new enum with related values and use it as a standard sort when defining your process group. You need to use the enum and field the underlying values once you return with the async process merchandise capabilities.

import Basis

func calculateNumber() async -> Int {
    await withCheckedContinuation { c in
        DispatchQueue.essential.asyncAfter(deadline: .now() + 4) {
            c.resume(with: .success(42))
        }
    }
}

func calculateString() async -> String {
    await withCheckedContinuation { c in
        DispatchQueue.essential.asyncAfter(deadline: .now() + 2) {
            c.resume(with: .success("The that means of life is: "))
        }
    }
}

@essential
struct MyProgram {
    
    static func essential() async {
        
        enum TaskSteps {
            case first(Int)
            case second(String)
        }

        await withTaskGroup(of: TaskSteps.self) { group in
            group.async {
                .first(await calculateNumber())
            }
            group.async {
                .second(await calculateString())
            }

            var outcome: String = ""
            for await res in group {
                swap res {
                case .first(let worth):
                    outcome = outcome + String(worth)
                case .second(let worth):
                    outcome = worth + outcome
                }
            }
            print(outcome)
        }
    }
}

After the duties are accomplished you’ll be able to swap the sequence components and carry out the ultimate operation on the outcome based mostly on the wrapped enum worth. This little trick will assist you to run all sort of duties with totally different return sorts to run parallel utilizing the brand new Duties APIs. 👍

Unstructured and indifferent duties

As you might need observed this earlier than, it isn’t potential to name an async API from a sync perform. That is the place unstructured duties may also help. An important factor to notice right here is that the lifetime of an unstructured process is just not certain to the creating process. They will outlive the dad or mum, they usually inherit priorities, task-local values, deadlines from the dad or mum. Unstructured duties are being represented by a process deal with that you should utilize to cancel the duty.

import Basis

func calculateFirstNumber() async -> Int {
    await withCheckedContinuation { c in
        DispatchQueue.essential.asyncAfter(deadline: .now() + 3) {
            c.resume(with: .success(42))
        }
    }
}

@essential
struct MyProgram {
    
    static func essential() {
        Activity(precedence: .background) {
            let deal with = Activity { () -> Int in
                print(Activity.currentPriority == .background)
                return await calculateFirstNumber()
            }
            
            let x = await deal with.get()
            print("The that means of life is:", x)
            exit(EXIT_SUCCESS)
        }
        dispatchMain()
    }
}

You may get the present precedence of the duty utilizing the static currentPriority property and examine if it matches the dad or mum process precedence (in fact it ought to match it). ☺️

So what is the distinction between unstructured duties and indifferent duties? Effectively, the reply is sort of easy: unstructured process will inherit the dad or mum context, alternatively indifferent duties will not inherit something from their dad or mum context (priorities, task-locals, deadlines).

@essential
struct MyProgram {
    
    static func essential() {
        Activity(precedence: .background) {
            Activity.indifferent {
                
                print(Activity.currentPriority == .background)
                let x = await calculateFirstNumber()
                print("The that means of life is:", x)
                exit(EXIT_SUCCESS)
            }
        }
        dispatchMain()
    }
}

You possibly can create a indifferent process by utilizing the indifferent technique, as you’ll be able to see the precedence of the present process contained in the indifferent process is unspecified, which is certainly not equal with the dad or mum precedence. By the best way it is usually potential to get the present process by utilizing the withUnsafeCurrentTask perform. You need to use this technique too to get the precedence or examine if the duty is cancelled. 🙅‍♂️

@essential
struct MyProgram {
    
    static func essential() {
        Activity(precedence: .background) {
            Activity.indifferent {
                withUnsafeCurrentTask { process in
                    print(process?.isCancelled ?? false)
                    print(process?.precedence == .unspecified)
                }
                let x = await calculateFirstNumber()
                print("The that means of life is:", x)
                exit(EXIT_SUCCESS)
            }
        }
        dispatchMain()
    }
}

There’s yet one more massive distinction between indifferent and unstructured duties. When you create an unstructured process from an actor, the duty will execute immediately on that actor and NOT in parallel, however a indifferent process will likely be instantly parallel. Which means an unstructured process can alter inner actor state, however a indifferent process cannot modify the internals of an actor. ⚠️

You may also benefit from unstructured duties in process teams to create extra advanced process constructions if the structured hierarchy will not suit your wants.

Activity native values

There’s yet one more factor I might like to point out you, we have talked about process native values numerous occasions, so this is a fast part about them. This characteristic is mainly an improved model of the thread-local storage designed to play good with the structured concurrency characteristic in Swift.

Typically you need to hold on customized contextual knowledge along with your duties and that is the place process native values are available. For instance you could possibly add debug info to your process objects and use it to search out issues extra simply. Donny Wals has an in-depth article about process native values, if you’re extra about this characteristic, you must undoubtedly learn his publish. 💪

So in observe, you’ll be able to annotate a static property with the @TaskLocal property wrapper, after which you’ll be able to learn this metadata inside an one other process. Any more you’ll be able to solely mutate this property by utilizing the withValue perform on the wrapper itself.

import Basis

enum TaskStorage {
    @TaskLocal static var title: String?
}

@essential
struct MyProgram {
    
    static func essential() async {
        await TaskStorage.$title.withValue("my-task") {
            let t1 = Activity {
                print("unstructured:", TaskStorage.title ?? "n/a")
            }
            
            let t2 = Activity.indifferent {
                print("indifferent:", TaskStorage.title ?? "n/a")
            }
            
            _ = await [t1.value, t2.value]
        }
    }
}

Duties will inherit these native values (besides indifferent) and you’ll alter the worth of process native values inside a given process as effectively, however these adjustments will likely be solely seen for the present process & little one duties. To sum this up, process native values are at all times tied to a given process scope.

As you’ll be able to see structured concurrency in Swift is rather a lot to digest, however when you perceive the fundamentals every part comes properly along with the brand new async/await options and Duties you’ll be able to simply assemble jobs for serial or parallel execution. Anyway, I hope you loved this text. 🙏