Chapters
Chapters

Chapters

Hide chapters

Swift Apprentice: Beyond the Basics

Second Edition · iOS 18 · Swift 6 · Xcode 16.2

Before You Begin

Section 0: 6 chapters
Show chapters Hide chapters

Section I: Beyond the Basics

Section 1: 13 chapters
Show chapters Hide chapters

12. Concurrency
Written by Ehab Amer

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

Heads up... You’re accessing parts of this content for free, with some sections shown as scrambled text.

Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now

The code you’ve written in the previous chapters of this book is all synchronous, meaning that it executes statement-by-statement, one step at a time, on what’s known as the main thread. Synchronous code is the most straightforward code to write and reason about, but it comes with a cost. Operations that take time to complete, including reading from a network or database, can stop your program while waiting for the operation to finish. For an interactive program such as a mobile app, this is a poor user experience because a great app needs to be fast and responsive.

By executing these operations asynchronously, your program can work on other tasks, such as updating the user interface while it waits for the blocking operation to complete. Working asynchronously introduces concurrency into your code. Your program will work on multiple tasks simultaneously.

Swift has always been capable of using concurrency libraries, such as Apple’s C-language-based Grand Central Dispatch. More recently, the core team has introduced a suite of language-level concurrency features, making it more efficient, safer and less error-prone than ever before.

This chapter gets you started in this new world of concurrency. You’ll learn essential concepts, including:

  • How to create unstructured and structured tasks.
  • How to perform cooperative task cancellation.
  • How to use the async / await pattern.
  • How to create and use actor and Sendable types.

Note: You may have heard of multithreaded programming. Concurrency in operating systems is built on top of threads, but you don’t need to manipulate them directly. In Swift-concurrency-speak, you use the term main actor instead of main thread. Actors are responsible for maintaining the consistency of objects you run concurrently in your program.

Basic Tasks

You’ll start with something super simple: Creating an unstructured task, which is an object that encapsulates some concurrent work. You can do that in an iOS Playground like this:

Task {
  print("Doing some work on a task")
}

print("Doing some work on the main actor")

The Task type takes a trailing closure with some work — print a message in this case — to do simultaneously with the main actor. Running this playground prints:

Doing some work on a task
Doing some work on the main actor

Changing the Order

In the example above, the code executed in the order the statements in the playground occurred. To see how that can change, replace the Task with some real work, like this:

Canceling a Task

Next, you’ll practice canceling a task. To do this, replace the code with the following:

Suspending a Task

Suppose you want to print the message Hello, wait for a second and then print Goodbye. You’d add this to your playground:

Wrapping it in a Function

Suppose you want to put that functionality into, well, a function. You might start like this:

The Structure of Tasks

You might have heard that Swift implements structured concurrency. That’s because tasks organize themselves into a tree-like structure with parent and child tasks.

Decoding an API — Learning Domains

So far, you’ve just seen contrived printing examples. To get more practice, you’ll asynchronously download and decode all of the “learning domains” from Kodeco using the website’s API. This activity will involve:

Async/Await in Action

Swift’s concurrency features make asynchronous code nearly as easy to read and write as synchronous code. Here’s how you implement fetchDomains:

Asynchronous Sequences

Another powerful abstraction that Swift concurrency gives you is the asynchronous sequence. Getting each element may cause the task to suspend:

Ordering Your Concurrency

In the previous examples, you made a new unstructured Task block whenever you needed an asynchronous context that could suspend and resume. Suppose you want to get the titles of two web pages.

Asynchronous Properties and Subscripts

Just as you saw with throws in Chapter 5, “Error Handling”, you can mark read-only computed properties with async:

Introducing Actors

So far, you’ve seen how to introduce concurrency into your code. However, concurrency isn’t without its risks. In particular, concurrent code can access and mutate the same state simultaneously, causing unpredictable results.

Converting a Class to an Actor

Here’s how you convert your Playlist from class to actor:

Making the Code Concurrent

You can now safely use playlists in concurrent code:

Using the Nonisolated Keyword

Actors, incidentally, are first-class types and can implement protocols, just like classes, structs and enums do:

Sendable

Types conforming to the Sendable protocol are isolated from shared mutations, so they’re safe to use concurrently or across threads. These types have value semantics, which you read about in detail in Chapter 8, “Value Types & Reference Types.” Actors only deal with Sendable types; in future versions of Swift, the compiler will enforce this.

Challenges

Here’s a set of challenges to test your concurrency knowledge. It’s best to try and solve them yourself, but solutions are available in the challenges download folder or at the printed book’s source code link in the introduction.

Challenge 1: Safe Teams

Using the above Playlist example as a guide, change the following class to make it safe to use in concurrent contexts:

Challenge 2: Custom Teams

Conform the asynchronous-safe type from the previous challenge to CustomStringConvertible.

Challenge 3: Sendable Teams

Make the following class Sendable:

Key Points

Concurrent programming is a crucial topic. Future versions of Swift will likely refine the tools and approaches for writing robust concurrent programs.

11. Advanced Protocols & Generics
13. Conclusion
Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.
© 2026 Kodeco Inc.

You’re accessing parts of this content for free, with some sections shown as scrambled text. Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.

Unlock now