Thead safe.

Author: BB9z

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019 B9Swift
+Copyright © 2019-2021 BB9z
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -15,6 +15,7 @@ Using Swift Package Manager or import manually.
 
 - NSHashTable free. It results better performance, support Liunx.
 - MulticastDelegate confirms `Sequence`, which means that lots of sequence features available.
+- Thread safe.
 - Other delightful details, eg: error handling optimization, debug log optimization.
 
 ## Background

Sources/B9MulticastDelegate/B9MulticastDelegate.swift

@@ -2,7 +2,7 @@
  MulticastDelegate
  B9Swift
 
- Copyright © 2019 BB9z
+ Copyright © 2019-2021 BB9z
  https://github.com/B9Swift/MulticastDelegate
 
  The MIT License (MIT)
@@ -12,12 +12,15 @@
 import Foundation
 
 /// Multicast delegate is a delegate that can have more than one element in its invocation list.
+///
+/// This class is thread safe.
 public final class MulticastDelegate<Element> {
 
     public init() {
     }
 
-    private lazy var store = [Weak]()
+    private var store = [Weak]()
+    private let lock = NSLock()
 
     /// Add an object to the multicast delegate.
     ///
@@ -31,10 +34,14 @@ public final class MulticastDelegate<Element> {
         guard let d = delegate else { return }
         let weakRef = Weak(object: d as AnyObject)
         guard let dobj = weakRef.object else {
-            print("[B9MulticastDelegate] warning: \(d) is not an object, it will be ignored. Adding a non-object to the delegate is meaningless.")
+            print("[B9MulticastDelegate] warning: \(d) is not an object, it will be ignored. Adding a non-object as delegate is meaningless.")
+            return
+        }
+        lock.lock()
+        defer { lock.unlock() }
+        if store.contains(where: { $0.object === dobj }) {
             return
         }
-        if store.contains(where: { $0.object === dobj }) { return }
         store.append(weakRef)
         underestimatedCount += 1
     }
@@ -46,8 +53,10 @@ public final class MulticastDelegate<Element> {
     /// - Complexity: O(*n*), where *n* is the length of the internal storage.
     public func remove(_ delegate: Element?) {
         guard let d = delegate else { return }
+        lock.lock()
         store.removeAll { $0.object === d as AnyObject || $0.object == nil }
         underestimatedCount = store.count
+        lock.unlock()
     }
 
     /// Calls the given closure on each object in the multicast delegate.
@@ -56,7 +65,10 @@ public final class MulticastDelegate<Element> {
     ///
     /// - Parameter invocation: A closure that takes an object in the multicast delegate as a parameter.
     public func invoke(_ invocation: (Element) throws -> ()) rethrows {
-        for ref in store {
+        lock.lock()
+        let shadowStore = store
+        lock.unlock()
+        for ref in shadowStore {
             if let d = ref.element {
                 try invocation(d)
             }
@@ -73,6 +85,8 @@ public final class MulticastDelegate<Element> {
     ///
     /// - Complexity: O(*n*), where *n* is the length of the internal storage.
     public func contains(object: AnyObject) -> Bool {
+        lock.lock()
+        defer { lock.unlock() }
         for weakRef in store {
             if weakRef.object === object {
                 return true
@@ -115,10 +129,10 @@ extension MulticastDelegate: CustomStringConvertible {
         let address = Unmanaged.passUnretained(self).toOpaque()
         let itemsDescriptions = map { "\t\($0)" }
         if itemsDescriptions.isEmpty {
-            return "<\(aType): \(address). elements: []>"
+            return "<\(aType) \(address): elements: []>"
         }
         return """
-        <\(aType): \(address). elements: [
+        <\(aType) \(address): elements: [
         \(itemsDescriptions.joined(separator: ",\n"))
         ]>
         """

Tests/B9MulticastDelegateTests/B9MulticastDelegateTests.swift

@@ -24,6 +24,13 @@ class TestKindC {
     }
 }
 
+class TestObject: CustomStringConvertible {
+    init(description: String) {
+        self.description = description
+    }
+    var description: String
+}
+
 final class B9MulticastDelegateTests: XCTestCase {
 
     func testAddAndRemove() {
@@ -94,7 +101,7 @@ final class B9MulticastDelegateTests: XCTestCase {
 
     func testWeakRef() {
         let d = MulticastDelegate<XCTestCase>()
-        autoreleasepool {
+        do {
             let obj = XCTestCase()
             d.add(obj)
             XCTAssert(d.debugContent == [obj])
@@ -133,6 +140,56 @@ final class B9MulticastDelegateTests: XCTestCase {
         }
         XCTAssertEqual(errorCount, 1)
     }
+
+    func testSequenceThreadSafe() {
+        let d = MulticastDelegate<CustomStringConvertible>()
+        let queueRead = DispatchQueue(label: "Read")
+        let queueWrite1 = DispatchQueue(label: "Write1")
+        let queueWrite2 = DispatchQueue(label: "Write2")
+        let readEnd = XCTestExpectation()
+        let writeEnd1 = XCTestExpectation()
+        let writeEnd2 = XCTestExpectation()
+
+        let objectCount = 2000
+        let objs = (0...objectCount).map { TestObject(description: String($0)) }
+        let objsProviderLock = NSLock()
+        var numberOfObjectProvided = 0
+        func object(of index: Int) -> TestObject {
+            objsProviderLock.lock()
+            defer { objsProviderLock.unlock() }
+            numberOfObjectProvided += 1
+            print("\(numberOfObjectProvided) + \(index)")
+            return objs[index]
+        }
+
+        queueWrite1.async {
+            for i in 0..<(objectCount/2) {
+                d.add(object(of: i))
+            }
+            writeEnd1.fulfill()
+        }
+        queueWrite2.async {
+            for i in (objectCount/2)..<objectCount {
+                d.add(object(of: i))
+            }
+            writeEnd2.fulfill()
+        }
+        queueRead.async {
+            for i in 0...20 {
+                usleep(100_000)  // 100 ms
+                print("loop \(i) start")
+                var counter = 0
+                d.forEach { obj in
+                    counter += 1
+                }
+                print("loop \(i) end, counter = \(counter)")
+            }
+            readEnd.fulfill()
+        }
+        wait(for: [readEnd, writeEnd1, writeEnd2], timeout: 10)
+        assert(d.debugContent.count == objectCount)
+        print("end")
+    }
 }
 
 // MARK: -