Description
Book SynopsisBuild solid software with modern and safe concurrency features. Concurrency is one of the hardest problems in computer science. For years, computer scientists and engineers have developed different strategies for dealing with concurrency. However, the original concurrency primitives are complicated and difficult to understand, and even harder to implement.
Using the new async/await APIs in Swift, this book will explain how your code can abstract a lot of the complexity with a simpler interface so you never have to deal with concurrency primitives such as semaphores, locks, and threads yourself. This will allow you to write concurrent code that is easier to read, easier to write, and easier to maintain. These new APIs are deeply ingrained into Swift, offering compile-level features that will keep you from writing dangerous concurrent code.
You''ll start by exploring why concurrency is hard to implement in a traditional system. Explaining the definition of concu
Table of Contents
Chapter 1: Introduction to Concurrency
• What is concurrency?
• Why is concurrency hard to implement?
• Existing methods to implement concurrency in Apple Platforms (before async/await).
Chapter 2: Async/Await Basics
• The keywords and components that play a role in the new concurrency system
• Explaining the `async` keyword
• Explaining the `await` keyword
• Understanding tasks
• Understanding the meaning of Continuations.
Chapter 3: Introducing Structured Concurrency
• Understanding structured concurrency
• Using the `async let` construct to create concurrency.
• Migrating older delegate and callback-based code into async/await.
Chapter 4: The Task Tree
• The Task Tree structure
• Understanding Task cancellation
• What is cooperative task cancellation?
Chapter 5: Task Groups
• Understanding and implementing task groups.
• Implementing concurrency with `withThrowingTaskGroup`
• Understanding `withTaskGroup`.
Chapter 6: Unstructured Concurrency
• Launching concurrent tasks from non-concurrent contexts.
• Understanding detached tasks and how to use them.
Chapter 7: Actors and Global Actors
• Understanding actors as reference types.
• The purpose of state isolation.
• Understanding the purpose of global actors.
Chapter 8: Final Bits
• Understanding the @TaskLocal property wrapper
• Using the `AsyncSequence` protocol in Swift.
• Using AsyncStream to receive events in an awaited loop.
• Sendable types
Audience: Advanced
