Swift 6 appeared at WWDC 2024, and all of us rushed emigrate all our apps to it … properly, probably not. We have been fairly proud of what we obtained at WWDC 2021 — Swift 5.5’s shiny new structured concurrency framework that helped us write protected code extra swiftly with async/await and actors. Swift 6 appeared to interrupt every thing, and it felt like a good suggestion to attend some time.
One yr later, the migration path appears to be like so much smoother, with heaps extra guideposts. Preserve studying to learn the way a lot simpler it’s turn into.
From Single-Thread to Concurrency
The aim of Swift 6.2 concurrency is to simplify your app improvement. It identifies three phases, the place you introduce concurrency explicitly, as and while you want it:
-
Run every thing on the primary thread: Begin with synchronous execution on the primary thread — if each operation is quick sufficient, your app’s UI gained’t grasp.
-
async/await: If you must carry out a gradual operation, create and
await an async operate to do the work. This operate nonetheless runs on the primary thread, which interleaves its work with work from different duties, like responding to the consumer scrolling or tapping. For instance, in case your app must obtain information from a server, your asynchronous operate can do some setup then await a URLSession technique that runs on a background thread. At this level, your operate suspends, and the primary thread is free to do another work. When the URLSession technique finishes, your operate is able to resume execution on the primary thread, often to offer some new information to show to the consumer.
-
Concurrency: As you add extra asynchronous operations to the primary thread, your app’s UI may turn into much less responsive. Profile your app with Devices to seek out efficiency issues and see in case you can repair the issue — pace up the gradual operation — with out concurrency. If not, introduce concurrency to maneuver that operation to a background thread and maybe use
async let or process teams to run sub-tasks in parallel to make the most of the a number of CPUs on the gadget.
Isolation Domains
Swift 6.2 concurrency goals to get rid of information races, which occur when a course of on one thread modifies information whereas a course of on one other thread is accessing that information. Knowledge races can solely come up when your app has mutable objects, which is why Swift encourages you to make use of let and worth sorts like struct as a lot as doable.
The principle instruments to forestall information races are information isolation and isolation domains:
The vital function of an isolation area is the security it supplies. Mutable state can solely be accessed from one isolation area at a time. You possibly can cross mutable state from one isolation area to a different, however you possibly can by no means entry that state concurrently from a distinct area. This assure is validated by the compiler.
There are three classes of isolation area:
- Actor
- International actor
- Non-isolated
Actors shield their mutable objects by sustaining a serial queue for asynchronous requests coming from outdoors their isolation area. A GlobalActor will need to have a static property known as shared that exposes an actor occasion that you just make globally accessible — you don’t must inject the actor from one sort to a different, or into the SwiftUI setting.
From Embracing Swift concurrency:
Nonisolated code could be very versatile, as a result of you possibly can name it from wherever: in case you name it from the primary actor, it should keep on the primary actor. Should you name it from a background thread, it should keep on a background thread. This makes it a terrific default for general-purpose libraries.
Knowledge isolation ensures that non-isolated entities can not entry the mutable state of different domains, so non-isolated capabilities and variables are at all times protected to entry from some other area.
Non-isolated is the default area at swift.org as a result of non-isolated code can not mutate state protected in one other area. Nevertheless, new Xcode 26 initiatives may have MainActor because the default isolation area, so each operation runs on the primary thread except you do one thing to maneuver work onto a background thread. The principle thread is serial, so mutable MainActor objects might be accessed by at most one course of at a time.
Migrating to Swift 6.2
Swift.org Migration Information
The Swift Migration Information suggests a course of for migrating Swift 5 code to Swift 6. Whereas in Swift 5 language mode, incrementally allow Swift 6 checking in your undertaking’s Construct Settings. Allow these settings one after the other, in any order, and tackle any points that come up:
Upcoming Options prompt by swift.org’s migration technique
Upcoming Options prompt by swift.org’s migration technique
In your undertaking’s Construct Settings, these are in Swift Compiler — Upcoming Options:
Upcoming Options recommendations in Xcode Construct Settings
Upcoming Options recommendations in Xcode Construct Settings
Be aware: I don’t see a precise match for GlobalConcurrency, but it surely may be Remoted International Variables.
Then, allow full concurency checking to activate the remaining information isolation checks. In Xcode, that is the Strict Concurrency Checking setting in Swift Compiler — Concurrency.
Xcode Construct Settings: Swift Compiler — Concurrency
Xcode Construct Settings: Swift Compiler — Concurrency
Xcode 26 Default Settings
New Xcode 26 initiatives may have these default settings for the opposite two Swift Compiler — Concurrency settings:
-
Approachable Concurrency: Sure: Permits a set of upcoming options that make simpler to work with concurrency.
-
Default Actor Isolation: MainActor: Isolates code on the
MainActor except you mark it as one thing else.
Enabling Approachable Concurrency allows a number of Upcoming Options, together with two of the swift.org’s migration technique recommendations:
Upcoming Options that Approachable Concurrency allows
Upcoming Options that Approachable Concurrency allows
If this raises too many points, disable Approachable Concurrency and check out the swift.org migration technique as a substitute.
Getting Began
Use the Obtain Supplies button on the high or backside of this text to obtain the starter undertaking, then open it in Xcode 26 (beta).
TheMet is a undertaking from SwiftUI Apprentice. It searches The Metropolitan Museum of Artwork, New York for objects matching the consumer’s question time period.
TheMet app: seek for Persimmon
TheMet app: seek for Persimmon
TheMetService has two strategies:
-
getObjectIDs(from:) constructs the question URL and downloads ObjectID values of artwork objects that match the question time period.
-
getObject(from:) fetches the Object for a selected ObjectID.
TheMetStore instantiates TheMetService and, in fetchObjects(for:) calls getObjectIDs(from:) then loops over the array of ObjectID to populate its objects array.
ContentView instantiates TheMetStore and calls its fetchObjects(from:) technique when it seems and when the consumer enters a brand new question time period.
The pattern app makes use of this Thread extension from SwiftLee’s publish Swift 6.2: A primary take a look at the way it’s altering Concurrency to point out which threads fetchObjects(for:), getObjectIDs(from:) and getObject(from:) are working on.
nonisolated extension Thread {
/// A comfort technique to print out the present thread from an async technique.
/// It is a workaround for compiler error:
/// Class property 'present' is unavailable from asynchronous contexts;
/// Thread.present can't be used from async contexts.
/// See: https://github.com/swiftlang/swift-corelibs-foundation/points/5139
public static var currentThread: Thread {
return Thread.present
}
}
On this tutorial, you’ll migrate TheMet to Swift 6.2 concurrency.
Construct and run and watch the console:
Retailer and Service strategies working on background threads
Retailer and Service strategies working on background threads
TheMetStore and TheMetService strategies run totally on background threads, besides when fetchObjects(for:) appends an object to objects, which ContentView shows. Nevertheless, in Swift 6.2’s three-phase app improvement course of, solely the URLSession technique must run off the primary thread. You’ll quickly repair this!
