Swift：结构线安全阵列与NSLOCK崩溃

Question

我正在尝试以最有效，最安全的方式实现线程安全阵列组件，并得到单位测试的支持。

到目前为止，我更喜欢struct数组，而不是保留一个值类型，而不是参考类型。

但是，当我在下面运行测试时，我仍然会有随机崩溃，但我没有解释：

这是我的thread> threadssafe array class：andray class：and

public struct SafeArray<T>: RangeReplaceableCollection {
    public typealias Element = T
    public typealias Index = Int
    public typealias SubSequence = SafeArray<T>
    public typealias Indices = Range<Int>

    private var array: [T]
    
    private var locker = NSLock()
    private func lock() { locker.lock() }
    private func unlock() { locker.unlock() }

    // MARK: - Public methods

    // MARK: - Initializers
    public init<S>(_ elements: S) where S: Sequence, SafeArray.Element == S.Element {
        array = [S.Element](elements)
    }

    public init() { self.init([]) }

    public init(repeating repeatedValue: SafeArray.Element, count: Int) {
        let array = Array(repeating: repeatedValue, count: count)
        self.init(array)
    }
}

extension SafeArray {
    // Single  action

    public func get() -> [T] {
        lock(); defer { unlock() }
        return Array(array)
    }

    public mutating func set(_ array: [T]) {
        lock(); defer { unlock() }
        self.array = Array(array)
    }
}

xcunittest code：

final class ConcurrencyTests: XCTestCase {
    
    private let concurrentQueue1 = DispatchQueue.init(label: "concurrentQueue1",
                                                      qos: .background,
                                                      attributes: .concurrent,
                                                      autoreleaseFrequency: .inherit,
                                                      target: nil)

    private let concurrentQueue2 = DispatchQueue.init(label: "concurrentQueue2",
                                                      qos: .background,
                                                      attributes: .concurrent,
                                                      autoreleaseFrequency: .inherit,
                                                      target: nil)

    
    private var safeArray = SafeArray(["test"])

    func wait(for expectations: XCTestExpectation, timeout seconds: TimeInterval) {
        wait(for: [expectations], timeout: seconds)
    }

    func waitForMainRunLoop() {
        let mainRunLoopExpectation = expectation(description: "mainRunLoopExpectation")
        DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { mainRunLoopExpectation.fulfill() }
        wait(for: mainRunLoopExpectation, timeout: 0.5)
    }

    func waitFor(_ timeout: TimeInterval) {
        let mainRunLoopExpectation = expectation(description: "timeoutExpectation")
        DispatchQueue.main.asyncAfter(deadline: .now() + timeout) { mainRunLoopExpectation.fulfill() }
        wait(for: mainRunLoopExpectation, timeout: timeout + 0.5)
    }
    
    override func setUpWithError() throws {
        try super.setUpWithError()
        safeArray = SafeArray(["test"])
    }

    func testSafeArrayGet() {
        var thread1: Thread!
        var thread2: Thread!
        
        concurrentQueue1.async {
            thread1 = Thread.current
            let startTime = Date()
            for i in 0...1_000_000 {
                self.safeArray.set(["modification"])
                print("modification \(i)")
            }
            print("time modification: \(Date().timeIntervalSince(startTime))")
        }

        concurrentQueue2.async {
            thread2 = Thread.current
            let startTime = Date()
            for i in 0...1_000_000 {
                let _ = self.safeArray.get()
                print("read \(i)")
            }
            print("time read: \(Date().timeIntervalSince(startTime))")
        }

        waitFor(10)

        XCTAssert(!thread1.isMainThread && !thread2.isMainThread)
        XCTAssert(thread1 != thread2)
    }
}

edit：editi借助课程和简单的方法使其线程安全，我崩溃了。这是一个非常简单的测试，崩溃了：

class TestClass {
        var test = ["test"]
        let nsLock = NSLock()
        
        func safeSet(_ string: String) {
            nsLock.lock()
            test[0] = string // crash
            nsLock.unlock()
        }
    }
    
    func testStructThreadSafety() {
        let testClass = TestClass()
        
        DispatchQueue.concurrentPerform(iterations: 1_000_000) { i in
            testClass.safeSet("modification \(i)")
            let _ = testClass.test[0]
        }
        
        XCTAssert(true)
    }

为什么会崩溃？我在做什么错？

请注意，如果我将其作为类我不会崩溃，但是我希望将其保留为结构。