Add thread safety to Clock

Signed-off-by: Seweryn Plażuk <[email protected]>

Author: Seweryn Plażuk

Kronos.xcodeproj/project.pbxproj

@@ -23,6 +23,7 @@
 		930B39DD2051E6D300360BA2 /* TimeStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = 930B39DC2051E6D300360BA2 /* TimeStorage.swift */; };
 		930B39E02051F26500360BA2 /* TimeStorageTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 930B39DE2051F25300360BA2 /* TimeStorageTests.swift */; };
 		C201748E1BD5509D00E4FE18 /* Kronos.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = C20174831BD5509D00E4FE18 /* Kronos.framework */; };
+		E5CC90032BFCA6C2009B0B82 /* UnfairLock.swift in Sources */ = {isa = PBXBuildFile; fileRef = E5CC90022BFCA6C2009B0B82 /* UnfairLock.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -58,6 +59,7 @@
 		C2C036D41C2B180D003FB853 /* UniversalFramework_Base.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = UniversalFramework_Base.xcconfig; sourceTree = "<group>"; };
 		C2C036D51C2B180D003FB853 /* UniversalFramework_Framework.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = UniversalFramework_Framework.xcconfig; sourceTree = "<group>"; };
 		C2C036D61C2B180D003FB853 /* UniversalFramework_Test.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = UniversalFramework_Test.xcconfig; sourceTree = "<group>"; };
+		E5CC90022BFCA6C2009B0B82 /* UnfairLock.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UnfairLock.swift; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -124,6 +126,7 @@
 				26447D7B1D6E54D400159BEE /* TimeFreeze.swift */,
 				930B39DC2051E6D300360BA2 /* TimeStorage.swift */,
 				5DB5A05F2BAAF67D0069CCF9 /* PrivacyInfo.xcprivacy */,
+				E5CC90022BFCA6C2009B0B82 /* UnfairLock.swift */,
 			);
 			path = Sources;
 			sourceTree = "<group>";
@@ -234,6 +237,7 @@
 				26447D7E1D6E54D400159BEE /* InternetAddress.swift in Sources */,
 				26447D811D6E54D400159BEE /* NTPClient.swift in Sources */,
 				26447D7F1D6E54D400159BEE /* Data+Bytes.swift in Sources */,
+				E5CC90032BFCA6C2009B0B82 /* UnfairLock.swift in Sources */,
 				26447D841D6E54D400159BEE /* TimeFreeze.swift in Sources */,
 				26447D821D6E54D400159BEE /* NTPPacket.swift in Sources */,
 				26447D801D6E54D400159BEE /* NSTimer+ClosureKit.swift in Sources */,

Sources/Clock.swift

@@ -25,15 +25,39 @@ public typealias AnnotatedTime = (
 /// print(Clock.now)
 /// ```
 public struct Clock {
+    private static let unfairLock = UnfairLock()
+
+    private static var _stableTime: TimeFreeze?
+    private static var _storage = TimeStorage(storagePolicy: .standard)
+
     private static var stableTime: TimeFreeze? {
-        didSet {
-            self.storage.stableTime = self.stableTime
+        get {
+            self.unfairLock.synchronized {
+                return self._stableTime
+            }
+        }
+        set {
+            self.unfairLock.synchronized {
+                self._stableTime = newValue
+                self._storage.stableTime = newValue
+            }
         }
     }
 
     /// Determines where the most current stable time is stored. Use TimeStoragePolicy.appGroup to share
     /// between your app and an extension.
-    public static var storage = TimeStorage(storagePolicy: .standard)
+    public static var storage: TimeStorage {
+        get {
+            self.unfairLock.synchronized {
+                return self._storage
+            }
+        }
+        set {
+            self.unfairLock.synchronized {
+                self._storage = newValue
+            }
+        }
+    }
 
     /// The most accurate timestamp that we have so far (nil if no synchronization was done yet)
     public static var timestamp: TimeInterval? {

Sources/UnfairLock.swift

@@ -0,0 +1,29 @@
+import os.lock
+
+final class UnfairLock {
+    private let lockPointer: os_unfair_lock_t
+
+    init() {
+        self.lockPointer = .allocate(capacity: 1)
+        self.lockPointer.initialize(to: os_unfair_lock())
+    }
+
+    deinit {
+        self.lockPointer.deinitialize(count: 1)
+        self.lockPointer.deallocate()
+    }
+
+    func synchronized<T>(_ block: () -> T) -> T {
+        self.lock()
+        defer { self.unlock() }
+        return block()
+    }
+
+    private func lock() {
+        os_unfair_lock_lock(self.lockPointer)
+    }
+
+    private func unlock() {
+        os_unfair_lock_unlock(self.lockPointer)
+    }
+}