🔒 We explore the concept of "reentrancy" in actors, and how innocently adding `async`-`await` to an actor method can open you up to a world of race conditions. This problem also shows up when we naively communicate between actors, but we can solve things in a non-naive way and make actor communication completely synchronous.

🔒 Using an actor seems to have forced us from a synchronous context to an asynchronous one, but it doesn't have to be this way. We will show how with the proper tools we can squash many `await`s down to a single one, and we will use "serial executors" to better understand how an actor enqueues work behind the scenes.

🔒 After fighting with legacy locking and mutexes let's explore a modern alternative: actors. We will refactor our data race-sensitive class to an actor and see just how simple and flexible its implementation can be, and we will grapple with something it introduces that locking did not: suspension points.

🔒 We explore the most modern locking primitive in Swift: `Mutex`. It has some serious smarts when it comes to protecting nonsendable state across threads in a synchronous manner, but it also has a serious bug that you should be aware of.