106 lines
3.1 KiB
Swift
106 lines
3.1 KiB
Swift
//
|
|
// MultiThreadDictionary.swift
|
|
// Tusker
|
|
//
|
|
// Created by Shadowfacts on 5/6/20.
|
|
// Copyright © 2020 Shadowfacts. All rights reserved.
|
|
//
|
|
|
|
import Foundation
|
|
import os
|
|
|
|
// once we target iOS 16, replace uses of this with OSAllocatedUnfairLock<[Key: Value]>
|
|
// to make the lock semantics more clear
|
|
@available(iOS, obsoleted: 16.0)
|
|
class MultiThreadDictionary<Key: Hashable & Sendable, Value: Sendable> {
|
|
private let lock: any Lock<[Key: Value]>
|
|
|
|
init() {
|
|
if #available(iOS 16.0, *) {
|
|
self.lock = OSAllocatedUnfairLock(initialState: [:])
|
|
} else {
|
|
self.lock = MutexLock(initialState: [:])
|
|
}
|
|
}
|
|
|
|
subscript(key: Key) -> Value? {
|
|
get {
|
|
return lock.withLock { dict in
|
|
dict[key]
|
|
}
|
|
}
|
|
set(value) {
|
|
lock.withLock { dict in
|
|
dict[key] = value
|
|
}
|
|
}
|
|
}
|
|
|
|
/// If the result of this function is unused, it is preferable to use `removeValueWithoutReturning` as it executes asynchronously and doesn't block the calling thread.
|
|
func removeValue(forKey key: Key) -> Value? {
|
|
return lock.withLock { dict in
|
|
dict.removeValue(forKey: key)
|
|
}
|
|
}
|
|
|
|
func contains(key: Key) -> Bool {
|
|
return lock.withLock { dict in
|
|
dict.keys.contains(key)
|
|
}
|
|
}
|
|
|
|
func withLock<R>(_ body: @Sendable (inout [Key: Value]) throws -> R) rethrows -> R where R: Sendable {
|
|
return try lock.withLock(body)
|
|
}
|
|
}
|
|
|
|
// TODO: replace this only with OSAllocatedUnfairLock
|
|
@available(iOS, obsoleted: 16.0)
|
|
fileprivate protocol Lock<State> {
|
|
associatedtype State
|
|
func withLock<R>(_ body: @Sendable (inout State) throws -> R) rethrows -> R where R: Sendable
|
|
}
|
|
|
|
@available(iOS 16.0, *)
|
|
extension OSAllocatedUnfairLock: Lock {
|
|
}
|
|
|
|
// something is wrong with the UnfairLock impl and it results in segv_accerrs
|
|
fileprivate class MutexLock<State>: Lock {
|
|
private var state: State
|
|
private var lock = NSLock()
|
|
|
|
init(initialState: State) {
|
|
self.state = initialState
|
|
}
|
|
|
|
func withLock<R>(_ body: @Sendable (inout State) throws -> R) rethrows -> R where R : Sendable {
|
|
if !lock.lock(before: Date(timeIntervalSinceNow: 1)) {
|
|
// if we can't acquire the lock after 1 second, something has gone catastrophically wrong
|
|
fatalError()
|
|
}
|
|
defer { lock.unlock() }
|
|
return try body(&state)
|
|
}
|
|
}
|
|
|
|
//// from http://www.russbishop.net/the-law
|
|
//fileprivate class UnfairLock<State>: Lock {
|
|
// private var lock: UnsafeMutablePointer<os_unfair_lock>
|
|
// private var state: State
|
|
// init(initialState: State) {
|
|
// self.state = initialState
|
|
// self.lock = .allocate(capacity: 1)
|
|
// self.lock.initialize(to: os_unfair_lock())
|
|
// }
|
|
// deinit {
|
|
// self.lock.deinitialize(count: 1)
|
|
// self.lock.deallocate()
|
|
// }
|
|
// func withLock<R>(_ body: (inout State) throws -> R) rethrows -> R where R: Sendable {
|
|
// os_unfair_lock_lock(lock)
|
|
// defer { os_unfair_lock_unlock(lock) }
|
|
// return try body(&state)
|
|
// }
|
|
//}
|