Question: Shouldn't AnyCallable store(in:) be thread safe?

[bofeizhu]

What if store(in:) were called from multiple threads? Wouldn't that break the current implementation?

[maximkrouk]

I think it shouldn't, most of the time you don't need it so synchronization should be implemented only for specific cases as needed...

[broadwaylamb]

Since the argument passed in this method is inout, the language prevents you from calling it simultaneously from multiple threads by crashing. See https://swift.org/blog/swift-5-exclusivity/.

[maximkrouk]

@bofeizhu you may use something like that

import Foundation

@propertyWrapper
public struct ThreadSafeWithLock<Value> {
  private var value: Value
  private let lock: NSLocking
  public var locksOnRead: Bool = false

  public init(
    wrappedValue: Value,
    _ lock: NSLocking = NSLock(),
    locksOnRead: Bool = false
  ) {
    self.value = wrappedValue
    self.lock = lock
    self.locksOnRead = locksOnRead
  }

  public var wrappedValue: Value {
    get {
      if locksOnRead {
        return lock.execute { value }
      } else {
        return value
      }
    }
    set { lock.store(newValue, in: &value) }
  }
}

@ThreadSafeWithLock
var subscriptions: Set<AnyCancellable> = []

publisher
  .sink { ... }
  .store(in &subscriptions)

import Foundation

extension NSLocking {
  /// Atomically stores new value in object
  @inlinable
  public func store<T>(_ value: T, in object: inout T) {
    mutate(&object, with: { $0 = value })
  }

  /// Atomically mutates object with closure
  @inlinable
  public func mutate<T: AnyObject>(_ object: T, with closure: (T) -> Void) {
    execute { closure(object) }
  }

  /// Atomically mutates object with closure
  @inlinable
  public func mutate<T>(_ object: inout T, with closure: (inout T) -> Void) {
    execute { closure(&object) }
  }

  /// Atomically mutates object with closure
  @inlinable
  public func set<T: AnyObject, Value>(
    _ object: T,
    _ keyPath: ReferenceWritableKeyPath<T, Value>,
    _ value: Value
  ) {
    execute { object[keyPath: keyPath] = value }
  }

  /// Atomically mutates object with closure
  @inlinable
  public func set<T, Value>(_ object: inout T, _ keyPath: WritableKeyPath<T, Value>, _ value: Value)
  {
    execute { object[keyPath: keyPath] = value }
  }

  /// Atomically executes a block of code
  @discardableResult
  @inlinable
  public func execute<T>(code closure: () -> T) -> T {
    lock()
    defer { unlock() }
    return closure()
  }
}