Stanford CS193p: iOS Development with SwiftUI | 2025 | L15: Multithreading

Key Concepts

• Multi-threading & Concurrency: Utilizing multiple threads to improve UI responsiveness and performance, particularly during long-running operations.
• Actors & Isolation: Employing actors to synchronize access to shared data, preventing data races and ensuring thread safety.
• SwiftUI & Main Actor: Understanding that SwiftUI views inherently operate on the main actor, simplifying UI-related concurrency.
• Asynchronous Programming: Leveraging async and await for non-blocking operations and managing asynchronous tasks.
• Concurrency Safety: Utilizing tools like strict concurrency checking and @mainActor to proactively identify and resolve potential concurrency issues.

UI Enhancements & Database Considerations (Part 1)

The lecture began with UI improvements to the Codebreaker app, including adding an animation to the search functionality and a "Completed" sorting option for games. Implementing the "Completed" sort revealed a challenge: using a computed property (game.isOver) within an NSPredicate caused a crash. This is because NSPredicate operates on stored data and cannot access Swift computed properties. Solutions included converting isOver to a stored property (requiring manual updates) or crafting a more complex predicate to determine game completion directly within the database query. This highlighted a key principle: database queries operate on stored data, not computed logic.

Swift Concurrency Foundations (Part 1)

The core of the first segment introduced fundamental Swift concurrency concepts. Multi-threading allows concurrent execution, and Actors provide a mechanism for synchronizing access to data, preventing data races. Actors enforce isolation, meaning functions and variables within an actor can only be accessed from within the actor itself or explicitly passed to other actors. Actors can also suspend execution when awaiting long-running operations, allowing other code within the actor to run. Key keywords include async (marking functions that can suspend) and await (calling asynchronous functions). The Sendable protocol ensures types can be safely passed across actor boundaries.

SwiftUI & Concurrency Management (Part 2)

The second segment focused on how these concurrency concepts apply within SwiftUI. Task closures attached to view modifiers execute when the view appears and are cancelled when it disappears, making them ideal for data loading tied to view visibility. These tasks inherently run on the main actor. The refreshable modifier provides a built-in pull-to-refresh functionality, also executing its closure on the main actor. Crucially, all SwiftUI views operate on the main actor, ensuring thread safety within the UI. However, code within the model layer is not inherently thread-safe and requires explicit concurrency management.

Actor Isolation & Data Updates (Part 2)

The @Observable mechanism for automatic view updates is main-actor isolated, meaning updates will eventually occur on the main actor when the view rebuilds. The @mainActor macro can be used to force code execution on the main actor, providing a convenient way to achieve actor isolation, but long-running tasks should not be placed on the main actor. Developers can create custom actors for complex operations, but cannot create @Observable actors. Asynchronous operations are initiated using Task and require await to suspend execution. Async sequences, like those obtained from URL.lines, allow for streaming data and potentially improving responsiveness when using for await loops.

Practical Application & Best Practices (Part 2)

Examples included implementing pull-to-refresh functionality and loading data from a network using await within a Task. The speaker demonstrated enabling strict concurrency checking in Xcode to proactively identify potential data races and illustrated how to resolve concurrency errors using @mainActor. Students were encouraged to explore advanced features like Maps and Swift Charts in their final projects.

Conclusion

The lecture provided a comprehensive introduction to multi-threading and concurrency in Swift, specifically within the context of SwiftUI development. The key takeaway is the importance of understanding actor isolation and utilizing tools like async/await, Task, and @mainActor to prevent data races and ensure a responsive user interface. SwiftUI simplifies concurrency management for UI-related code by automatically isolating views to the main actor, but developers must remain vigilant about thread safety in the model layer. Proactive concurrency checking is highly recommended to identify and resolve potential issues early in the development process.