在我的快速实践中，我编写了名为 OrderedSet 的简单结构。

我尝试将 OrderedSet 作为 GCD 串行队列的线程安全。

但它不起作用。测试结果不稳定。我期望是这样的:

20:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

但收到了类似的东西

2:[3, 19]

这里是 playground 代码:

import Foundation
import XCPlayground

struct OrderedSet<T: Equatable> {
    mutating func append(e: T) {
        dispatch_sync(q) {
            if !self.__elements.contains(e) {
                self.__elements.append(e)
            }
        }
    }
    var elements: [T] {
        var elements: [T] = []
        dispatch_sync(q) {
            elements = self.__elements
        }
        return elements
    }
    var count: Int {
        var ret = 0
        dispatch_sync(q) {
            ret = self.__elements.count
        }
        return ret
    }
    private var __elements: [T] = []
    private let q = dispatch_queue_create("OrderedSet.private.serial.queue", DISPATCH_QUEUE_SERIAL)
}
extension OrderedSet: CustomStringConvertible {
    var description: String {
        var text = ""
        dispatch_sync(q) {
            text = "\(self.__elements.count):\(self.__elements)"
        }
        return text
    }
}

// Test code
let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
let group = dispatch_group_create()

var testSet = OrderedSet<Int>()
for i in 0..<20 {
    dispatch_group_async(group, globalQueue) {
        testSet.append(i)
    }
}
dispatch_group_notify(group, globalQueue) {
    print("\(testSet)") // unstable result
}

XCPSetExecutionShouldContinueIndefinitely()

我检查了以下内容:

如果将 OrderdSet 定义为一个类(而不是结构)就可以了。

如果使用信号量而不是使用串行队列是可以的。

想知道struct和serial queue这对不稳定的原因。

----更新

我得到了预期的结果。

1. 类而不是结构

   import Foundation
   import XCPlayground
   
   class OrderedSet<T: Equatable> {
       func append(e: T) {
           dispatch_sync(q) {
               if !self.__elements.contains(e) {
                   self.__elements.append(e)
               }
           }
       }
       var elements: [T] {
           var elements: [T] = []
           dispatch_sync(q) {
               elements = self.__elements
           }
           return elements
       }
       var count: Int {
           var ret = 0
           dispatch_sync(q) {
               ret = self.__elements.count
           }
           return ret
       }
       private var __elements: [T] = []
       private let q = dispatch_queue_create("OrderedSet.private.serial.queue", DISPATCH_QUEUE_SERIAL)
   }
   extension OrderedSet: CustomStringConvertible {
       var description: String {
           var text = ""
           dispatch_sync(q) {
               text = "\(self.__elements.count):\(self.__elements)"
           }
           return text
       }
   }
   
   // Test code
   let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
   let group = dispatch_group_create()
   
   var testSet = OrderedSet<Int>()
   for i in 0..<20 {
       dispatch_group_async(group, globalQueue) {
           testSet.append(i)
       }
   }
   dispatch_group_notify(group, globalQueue) {
       print("\(testSet)") // It's OK
   }
   
   XCPSetExecutionShouldContinueIndefinitely()
   

2. 信号量代替串行队列

   import Foundation
   import XCPlayground
   
   struct OrderedSet<T: Equatable> {
       mutating func append(e: T) {
           dispatch_semaphore_wait(s, DISPATCH_TIME_FOREVER)
           if !self.__elements.contains(e) {
               self.__elements.append(e)
           }
           dispatch_semaphore_signal(s)
       }
       var elements: [T] {
           var elements: [T] = []
           dispatch_semaphore_wait(s, DISPATCH_TIME_FOREVER)
           elements = self.__elements
           dispatch_semaphore_signal(s)
           return elements
       }
       var count: Int {
           var ret = 0
           dispatch_semaphore_wait(s, DISPATCH_TIME_FOREVER)
           ret = self.__elements.count
           dispatch_semaphore_signal(s)
           return ret
       }
       private var __elements: [T] = []
       private let s = dispatch_semaphore_create(1)
   }
   extension OrderedSet: CustomStringConvertible {
       var description: String {
           var text = ""
           dispatch_semaphore_wait(s, DISPATCH_TIME_FOREVER)
           text = "\(self.__elements.count):\(self.__elements)"
           dispatch_semaphore_signal(s)
           return text
       }
   }
   
   // Test code
   let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
   let group = dispatch_group_create()
   
   var testSet = OrderedSet<Int>()
   for i in 0..<20 {
       dispatch_group_async(group, globalQueue) {
           testSet.append(i)
       }
   }
   dispatch_group_notify(group, globalQueue) {
       print("\(testSet)") // It's OK
   }
   
   XCPSetExecutionShouldContinueIndefinitely()
   

3. 本身带有 OrderdSet 的串行队列。

   import Foundation
   import XCPlayground
   
   struct OrderedSet<T: Equatable> {
       mutating func append(e: T) {
           if !self.__elements.contains(e) {
               self.__elements.append(e)
           }
       }
       var elements: [T] {
           return self.__elements
       }
       var count: Int {
           return self.__elements.count
       }
       private var __elements: [T] = []
   }
   extension OrderedSet: CustomStringConvertible {
       var description: String {
           return "\(self.__elements.count):\(self.__elements)"
       }
   }
   
   // Test code
   let globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
   let serialQueue = dispatch_queue_create("serial", DISPATCH_QUEUE_SERIAL)
   
   let group = dispatch_group_create()
   
   var testSet = OrderedSet<Int>()
   for i in 0..<20 {
       dispatch_group_async(group, globalQueue) {
           dispatch_sync(serialQueue) {
               testSet.append(i)
           }
       }
   }
   dispatch_group_notify(group, serialQueue) {
       print("\(testSet)") // It's OK
   }
   
   XCPSetExecutionShouldContinueIndefinitely()
   

最佳答案

此代码将捕获 testSet 的当前值:

dispatch_group_async(group, globalQueue) {
    testSet.append(i) // `testSet` inside the closure will be a copy of the `testSet` variable outside 
}

闭包执行后，内部testSet的值会被复制到外部testSet变量中。

想象一个并发世界:

• 10 个闭包同时运行，捕获外部 testSet 的初始值，即“0:[]”。

• 完成后，闭包内部的 10 个 testSet 副本尝试复制回唯一的外部 testSet。但是，只有一个赢家，比如说，外部 testSet 的当前值为“1:[3]”。

• 又一轮开始，捕获外部 testSet 的当前值“1:[3]”，附加 i，然后复制回来，产生奇怪的结果，比如说，“2:[3, 19]”

在您更新的案例 1 中，将 OrderedSet 更改为类，事情非常简单，testSet 通过引用捕获，并且所有线程都共享同一个对象。

在您更新的案例 3 中，通过使用串行队列，我猜每个追加和复制回操作都是串行的，因此您会产生一个完美的有序集。

情况 2 更为复杂。其实我还没有弄清楚引擎盖下发生了什么。而且我认为这更多是关于 swift 编译器的实现细节，并且可能会随着不同的 swift 版本而改变。似乎信号量是一种引用类型，因此“testSet”的所有副本都共享相同的信号量。我想编译器决定在这种情况下进行一些优化，并使 testSet 的所有副本 __element 指向同一个数组。因此结果包含所有 0..<20>

关于ios - swift 2 : struct thread-safety，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31626004/