Mutex, Atomics & Beyond

Mutex, Atomics & Beyond
24/04/2025
CocoaHeads Nantes

Transcript

1. Nicolás García Mutex, Atomics & Beyond
2. Nicolás García Mutex, Atomics & Beyond
3. var someVariable = true
4. var someVariable = true
5. class SomeClass { var someVariable = true }
6. // Well, someVariable is NOT thread-safe… class SomeClass { var someVariable = true }
7. class SomeClass { private var queue = DispatchQueue(…) private var _someVariable = true var someVariable: Bool { get { queue.sync { _someVariable } } set { queue.sync { self._someVariable = newValue } } } }
8. class SomeClass { // serialisation but at the cost of a new thread dispatch private var queue = DispatchQueue(…) private var _someVariable = true var someVariable: Bool { get { queue.sync { _someVariable } } set { queue.sync { self._someVariable = newValue } } } }
9. We have Swift Concurrency
10. // Swift Concurrency error: SomeClass is not Sendable class SomeClass { private var queue = DispatchQueue(…) private var _someVariable = true var someVariable: Bool { get { queue.sync { _someVariable } } set { queue.sync { self._someVariable = newValue } } } }
11. fi nal class SomeClass: @unchecked Sendable { private var queue = DispatchQueue(…) private var _someVariable = true var someVariable: Bool { get { queue.sync { _someVariable } } set { queue.sync { self._someVariable = newValue } } } }
12. fi nal class SomeClass: @unchecked Sendable { // trust me bro, its safe… private var queue = DispatchQueue(…) private var _someVariable = true var someVariable: Bool { get { queue.sync { _someVariable } } set { queue.sync { self._someVariable = newValue } } } }
13. The Swift 6 compiler is happy again
14. actor SomeActor { private var someVariable = true
 func getSomeVariable() -> Bool { someVariable } func setSomeVariable(_ newValue: Bool) { someVariable = newValue } }
15. actor SomeActor { private var someVariable = true
 func getSomeVariable() -> Bool { someVariable } func setSomeVariable(_ newValue: Bool) { someVariable = newValue } }
 
 Serialization + isolation + Sendable !
16. let actor = SomeActor() Task { let current = await actor.getSomeVariable() await actor.setSomeVariable(false) } 
 
 But a bit awkward for quick UI toggles or sync-style logic…
17. What else do we got ?
18. NSLock 🦕
19. fi nal class SomeClass { private var _someVariable = true private let lock = NSLock() var someVariable: Bool { get { lock.lock(); defer { lock.unlock() } // Don’t forget to unlock or you’ll risk a deadlock, otherwise -> NSRecursiveLock return _someVariable } set { lock.lock(); _someVariable = newValue lock.unlock() // unlocking in a di ff erent thread may cause unde fi ned behaviour } } }
20. os_unfair_lock
22. import OSLock fi nal class SomeClass { private var _someVariable = true private let lock = OSAllocatedUnfairLock() var someVariable: Bool { get { lock.withLock { _someVariable } } set { lock.withLock { _someVariable = newValue } } } }
23. OSAllocatedUnfairLock is currently the fastest lock in iOS
24. OSAllocatedUnfairLock is currently the fastest lock in iOS https://swiftrocks.com/thread-safety-in-swift
25. Swift 6 strict concurrency system is less forgiving now
26. Fast-backward to WWDC 2024
27. WWDC 2024 New Synchronization module announced at the end of “What’s new in Swift” (around 28:45) • https://developer.apple.com/videos/ play/wwdc2024/10136 • Low level primitives: Mutex and Atomics • SE-0433 https://github.com/swiftlang/ swift-evolution/blob/main/proposals/ 0433-mutex.md
28. But wasn’t there a Swift Atomics package ? (https://www.swift.org/blog/swift-atomics/ 01/10/2020)
29. https://github.com/apple/swift-atomics/pull/94
30. https://www.swift.org/blog/swift-5.9-released/ (18/09/2023)
31. Hello, 
 import Synchronization
32. import Synchronization Key points • Mutex and Atomics low level primitives • iOS 18 + • New keywords: ~Copyable, consuming, borrowing…
34. Non copyable types Ownership • Available since Swift 5.9 • It removes the copying capability of a type • “~” its called a negative constraint • Enforces strict ownership and move semantics • Borrowing • Temporarily gives access to a non copyable resource without transferring ownership • Consuming • Transfers ownership, leaving the original reference invalid • Bene fi ts • Prevention: common errors and unnecessary duplication • Performance: reducing the overhead of eventual copies • Expressiveness: more control over low memory management
35. Time taken running N parallel (trivial) tasks https://blog.jacobstechtavern.com/p/the-synchronisation-framework
36. The underlying os_unfair_lock in Mutex implementation… https://github.com/swiftlang/swift-evolution/blob/main/proposals/0433-mutex.md
37. Tool Era Concurrency Ready? Sendable? Swift Integration Global var 2000s ❌ ❌ ❌ Class ❌ ❌ ✅ DispatchQueue GCD ✅ (kind of) ❌ ✅ @unchecked Sendable Hack? ✅ ✅ (ish) 😬 Actor 2021 ✅ ✅ ✅✅ NSLock Legacy ✅ ❌ ❌ os_unfair_lock C-level ✅ ❌ ❌ OSAllocatedUnfairLock iOS 16+ ✅ ❌ ✅ Synchronization.Mutex iOS 18+ ✅ ✅ ✅✅✅ Thread-safety in Swift
38. Nice reads • https://swiftrocks.com/thread-safety-in-swift • https://developer.apple.com/documentation/os/osallocatedunfairlock • https://medium.com/@MdNiks/understanding-copyable-in-swift-5-9-non- copyable-types-for-safer-memory-management-564e328448e1 • https://blog.jacobstechtavern.com/p/the-synchronisation-framework
39. Who am I Freelance iOS & macOS Developer • Back to early 2013 • A fi rst experience with Eclipse IDE and Android SDK • Xcode 4.6 and an iPhone 4 • I’m sorry for those of you coming from the pre-ARC era 🦕 • Worked on IoT, video, banking and Cloud B2B and B2C apps
40. Nicolás García Mutex, Atomics & Beyond 
 yourAttention.unlock()
 Thank you ! Feel free to connect on LinkedIn