What are Sendable and @Sendable closures in Swift? – Donny Wals

One of many objectives of the Swift workforce with Swift’s concurrency options is to offer a mannequin that permits developer to put in writing secure code by default. Which means that there’s loads of time and vitality invested into ensuring that the Swift compiler helps builders detect, and forestall entire courses of bugs and concurrency points altogether.

One of many options that helps you forestall knowledge races (a standard concurrency concern) comes within the type of actors which I’ve written about earlier than.

Whereas actors are nice if you wish to synchronize entry to some mutable state, they don’t remedy each attainable concern you might need in concurrent code.

On this publish, we’re going to take a more in-depth take a look at the Sendable protocol, and the @Sendable annotation for closures. By the top of this publish, it is best to have understanding of the issues that Sendable (and @Sendable) purpose to resolve, how they work, and the way you should use them in your code.

Understanding the issues solved by Sendable

One of many trickiest elements of a concurrent program is to make sure knowledge consistency. Or in different phrases, thread security. Once we move situations of courses or structs, enum circumstances, and even closures round in an utility that doesn’t do a lot concurrent work, we don’t want to fret about thread security loads. In apps that don’t actually carry out concurrent work, it’s unlikely that two duties try and entry and / or mutate a bit of state at the very same time. (However not inconceivable)

For instance, you is likely to be grabbing knowledge from the community, after which passing the obtained knowledge round to a few capabilities in your most important thread.

As a result of nature of the primary thread, you’ll be able to safely assume that your whole code runs sequentially, and no two processes in your utility shall be engaged on the identical referencea on the identical time, doubtlessly creating a knowledge race.

To briefly outline a knowledge race, it’s when two or extra elements of your code try and entry the identical knowledge in reminiscence, and at the very least one among these accesses is a write motion. When this occurs, you’ll be able to by no means be sure in regards to the order through which the reads and writes occur, and you may even run into crashes for dangerous reminiscence accesses. All in all, knowledge races aren’t any enjoyable.

Whereas actors are a improbable strategy to construct objects that accurately isolate and synchronize entry to their mutable state, they’ll’t remedy all of our knowledge races. And extra importantly, it won’t be affordable so that you can rewrite your whole code to utilize actors.

Contemplate one thing like the next code:

class FormatterCache {
    var formatters = [String: DateFormatter]()

    func formatter(for format: String) -> DateFormatter {
        if let formatter = formatters[format] {
            return formatter
        }

        let formatter = DateFormatter()
        formatter.dateFormat = format
        formatters[format] = formatter

        return formatter
    }
}

func performWork() async {
    let cache = FormatterCache()
    let possibleFormatters = ["YYYYMMDD", "YYYY", "YYYY-MM-DD"]

    await withTaskGroup(of: Void.self) { group in
        for _ in 0..<10 {
            group.addTask {
                let format = possibleFormatters.randomElement()!
                let formatter = cache.formatter(for: format)
            }
        }
    }
}

On first look, this code won’t look too dangerous. We’ve got a category that acts as a easy cache for date formatters, and now we have a job group that may run a bunch of code in parallel. Every job will seize a random date format from the record of attainable format and asks the cache for a date formatter.

Ideally, we anticipate the formatter cache to solely create one date formatter for every date format, and return a cached formatter after a formatter has been created.

Nonetheless, as a result of our duties run in parallel there’s an opportunity for knowledge races right here. One fast repair could be to make our FormatterCache an actor and this is able to remedy our potential knowledge race. Whereas that will be resolution (and truly the very best resolution when you ask me) the compiler tells us one thing else after we attempt to compile the code above:

Seize of ‘cache’ with non-sendable kind ‘FormatterCache’ in a @Sendable closure

This warning is attempting to inform us that we’re doing one thing that’s doubtlessly harmful. We’re capturing a worth that can’t be safely handed via concurrency boundaries in a closure that’s speculated to be safely handed via concurrency boundaries.

⚠️ If the instance above doesn’t produce a warning for you, you will wish to allow strict concurrency checking in your mission’s construct settings for stricter Sendable checks (amongst different concurrency checks). You’ll be able to allow strict concurrecy settings in your goal’s construct settings. Check out this web page when you’re unsure how to do that.

With the ability to be safely handed via concurrency boundaries primarily signifies that a worth may be safely accessed and mutated from a number of duties concurrently with out inflicting knowledge races. Swift makes use of the Sendable protocol and the @Sendable annotation to speak this thread-safety requirement to the compiler, and the compiler can then test whether or not an object is certainly Sendable by assembly the Sendable necessities.

What these necessities are precisely will fluctuate a little bit relying on the kind of objects you take care of. For instance, actor objects are Sendable by default as a result of they’ve knowledge security built-in.

Let’s check out different kinds of objects to see what their Sendable necessities are precisely.

Sendable and worth sorts

In Swift, worth sorts present loads of thread security out of the field. While you move a worth kind from one place to the subsequent, a replica is created which signifies that every place that holds a replica of your worth kind can freely mutate its copy with out affecting different elements of the code.

This an enormous good thing about structs over courses as a result of they permit use to motive domestically about our code with out having to think about whether or not different elements of our code have a reference to the identical occasion of our object.

Due to this habits, worth sorts like structs and enums are Sendable by default so long as all of their members are additionally Sendable.

Let’s take a look at an instance:

// This struct just isn't sendable
struct Film {
    let formatterCache = FormatterCache()
    let releaseDate = Date()
    var formattedReleaseDate: String {
        let formatter = formatterCache.formatter(for: "YYYY")
        return formatter.string(from: releaseDate)
    }
}

// This struct is sendable
struct Film {
    var formattedReleaseDate = "2022"
}

I do know that this instance is a little bit bizarre; they don’t have the very same performance however that’s not the purpose.

The purpose is that the primary struct does probably not maintain mutable state; all of its properties are both constants, or they’re computed properties. Nonetheless, FormatterCache is a category that is not Sendable. Since our Film struct doesn’t maintain a replica of the FormatterCache however a reference, all copies of Film could be trying on the identical situations of the FormatterCache, which signifies that we is likely to be knowledge races if a number of Film copies would try and, for instance, work together with the formatterCache.

The second struct solely holds Sendable state. String is Sendable and because it’s the one property outlined on Film, film can also be Sendable.

The rule right here is that every one worth sorts are Sendable so long as their members are additionally Sendable.

Usually talking, the compiler will infer your structs to be Sendable when wanted. Nonetheless, you’ll be able to manually add Sendable conformance if you would like:

struct Film: Sendable {
    let formatterCache = FormatterCache()
    let releaseDate = Date()
    var formattedReleaseDate: String {
        let formatter = formatterCache.formatter(for: "YYYY")
        return formatter.string(from: releaseDate)
    }
}

Sendable and courses

Whereas each structs and actors are implicitly Sendable, courses should not. That’s as a result of courses are loads much less secure by their nature; all people that receives an occasion of a category truly receives a reference to that occasion. Which means that a number of locations in your code maintain a reference to the very same reminiscence location and all mutations you make on a category occasion are shared amongst all people that holds a reference to that class occasion.

That doesn’t imply we are able to’t make our courses Sendable, it simply signifies that we have to add the conformance manually, and manually be certain that our courses are literally Sendable.

We are able to make our courses Sendable by including conformance to the Sendable protocol:

ultimate class Film: Sendable {
    let formattedReleaseDate = "2022"
}

The necessities for a category to be Sendable are much like these for a struct.

For instance, a category can solely be Sendable if all of its members are Sendable. Which means that they have to both be Sendable courses, worth sorts, or actors. This requirement is similar to the necessities for Sendable structs.

Along with this requirement, your class have to be ultimate. Inheritance may break your Sendable conformance if a subclass provides incompatible overrides or options. For that reason, solely ultimate courses may be made Sendable.

Lastly, your Sendable class shouldn’t maintain any mutable state. Mutable state would imply that a number of duties can try and mutate your state, main to an information race.

Nonetheless, there are situations the place we would know a category or struct is secure to be handed throughout concurrency boundaries even when the compiler can’t show it.

In these circumstances, we are able to fall again on unchecked Sendable conformance.

Unchecked Sendable conformance

While you’re working with codebases that predate Swift Concurrency, likelihood is that you simply’re slowly working your method via your app in an effort to introduce concurrency options. Which means that a few of your objects might want to work in your async code, in addition to in your sync code. Which means that utilizing actor to isolate mutable state in a reference kind won’t work so that you’re caught with a category that may’t conform to Sendable. For instance, you might need one thing like the next code:

class FormatterCache {
    personal var formatters = [String: DateFormatter]()
    personal let queue = DispatchQueue(label: "com.dw.FormatterCache.(UUID().uuidString)")

    func formatter(for format: String) -> DateFormatter {
        return queue.sync {
            if let formatter = formatters[format] {
                return formatter
            }

            let formatter = DateFormatter()
            formatter.dateFormat = format
            formatters[format] = formatter

            return formatter
        }
    }
}

This formatter cache makes use of a serial queue to make sure synchronized entry to its formatters dictionary. Whereas the implementation isn’t perfect (we might be utilizing a barrier or perhaps even a plain previous lock as an alternative), it really works. Nonetheless, we are able to’t add Sendable conformance to our class as a result of formatters isn’t Sendable.

To repair this, we are able to add @unchecked Sendable conformance to our FormatterCache:

class FormatterCache: @unchecked Sendable {
    // implementation unchanged
}

By including this @unchecked Sendable we’re instructing the compiler to imagine that our FormatterCache is Sendable even when it doesn’t meet the entire necessities.

Having this function in our toolbox is extremely helpful if you’re slowly phasing Swift Concurrency into an present mission, however you’ll wish to assume twice, or perhaps even 3 times, if you’re reaching for @unchecked Sendable. It’s best to solely use this function if you’re actually sure that your code is definitely secure for use in a concurrent atmosphere.

Utilizing @Sendable on closures

There’s one final place the place Sendable comes into play and that’s on capabilities and closures.

Plenty of closures in Swift Concurrency are annotated with the @Sendable annotation. For instance, right here’s what the declaration for TaskGroup‘s addTask seems like:

public mutating func addTask(precedence: TaskPriority? = nil, operation: @escaping @Sendable () async -> ChildTaskResult)

The operation closure that’s handed to addTask is marked with @Sendable. Which means that any state that the closure captures should be Sendable as a result of the closure is likely to be handed throughout concurrency boundaries.

In different phrases, this closure will run in a concurrent method so we wish to ensure that we’re not by chance introducing a knowledge race. If all state captured by the closure is Sendable, then we all know for positive that the closure itself is Sendable. Or in different phrases, we all know that the closure can safely be handed round in a concurrent atmosphere.

Tip: to be taught extra about closures in Swift, check out my publish that explains closures in nice element.

Abstract

On this publish, you’ve realized in regards to the Sendable and @Sendable options of Swift Concurrency. You realized why concurrent packages require additional security round mutable state, and state that’s handed throughout concurrency boundaries in an effort to keep away from knowledge races.

You realized that structs are implicitly Sendable if all of their members are Sendable. You additionally realized that courses may be made Sendable so long as they’re ultimate, and so long as all of their members are additionally Sendable.

Lastly, you realized that the @Sendable annotation for closures helps the compiler be certain that all state captured in a closure is Sendable and that it’s secure to name that closure in a concurrent context.

I hope you’ve loved this publish. You probably have any questions, suggestions, or strategies to assist me enhance the reference then be at liberty to succeed in out to me on Twitter.