Modern Concurrency: Beyond the Basics

Heads up... You've reached locked video content where the transcript will be shown as obfuscated text.

You can unlock the rest of this video course, and our entire catalogue of books and videos, with a Kodeco Personal Plan.

Unlock now

Throughout this course, whenever you've needed to make quick changes that drive the UI, you've called MainActor.run to access MainActor from anywhere. Because your app runs on a single main thread, you can't create a second or third MainActor, so it does make sense that there's a default shared instance of that Actor that you can safely use from anywhere. There are other times you need an app wide single instance shared state. For example, the app's database layer is usually a singleton type that manages the state of a file on the disc. Image or data caches are also often single instance types. The authentication status of the user is valid app wide, whether they have logged in or not. Luckily, SWIFT allows you to create your own GlobalActors just like MainActor for situations where you need a single shared Actor that's accessible from anywhere. Annotating an Actor with the @globalActor attribute makes it automatically conform to the GlobalActor Protocol. Its only requirement is a static property called shared to expose an Actor instance that you make globally accessible. You don't need to inject the Actor from one type to another or into the SWIFT UI environment. So how do you write code in your app to work with singletons like databases or persistent caches? To avoid data erases, any method that accesses your GlobalActor needs to run on it. You just annotate the method with the GlobalActor. You can annotate a complete class with a GlobalActor and that will add that Actor's semantics to all its methods and properties as long as they aren't non-isolated. You can use the at annotation to group methods or entire types that can safely share mutable state in their own synchronized silo. In the next episode, you'll create a GlobalActor you can use as a persistent image cache layer.