arrays - 如果数组是值类型并因此被复制，那么它们为什么不是线程安全的？

Question

阅读 this我了解到:

Instances of value types are not shared: every thread gets its own copy.* That means that every thread can read and write to its instance without having to worry about what other threads are doing.

然后我被带到this答案及其评论

并被告知:

an array, which is not, itself, thread-safe, is being accessed from multiple threads, so all interactions must be synchronized.

关于每个线程都有自己的副本有人告诉我

if one thread is updating an array (presumably so you can see that edit from another queue), that simply doesn't apply

那根本不适用 <-- 为什么不呢？

我最初认为所有这一切都是因为数组，即值类型被包装到一个类中，但令我惊讶的是我被告知不是真的!所以我又回到了 Swift 101 :D

Answer 1

根本问题是“每个线程都有自己的副本”的解释。

是的，我们经常使用值类型来确保线程安全，方法是为每个线程提供其自己的对象副本(例如数组)。但这与声称值类型保证每个线程都将获得自己的副本不是一回事。

具体来说，使用闭包，多个线程可以尝试改变相同的值类型对象。下面的代码示例显示了一些与 Swift Array 值类型交互的非线程安全代码:

let queue = DispatchQueue.global()

var employees = ["Bill", "Bob", "Joe"]

queue.async {
    let count = employees.count
    for index in 0 ..< count {
        print("\(employees[index])")
        Thread.sleep(forTimeInterval: 1)
    }
}

queue.async { 
    Thread.sleep(forTimeInterval: 0.5)
    employees.remove(at: 0)
}

(您通常不会添加 sleep 调用；我只是将它们添加到显性竞争条件中，否则很难重现。您也不应该像这样从多个线程中改变一个对象同步，但我这样做是为了说明问题。)

在这些 async 调用中，您仍然指的是之前定义的相同 employees 数组。所以，在这个特定的例子中，我们会看到它输出“Bill”，它会跳过“Bob”(即使它被删除的是“Bill”)，它会输出“Joe”(现在是第二个项目)，并且然后它会崩溃尝试访问数组中的第三个项目，现在只剩下两个项目。

现在，我在上面说明的所有内容是，单个值类型可以在被另一个线程使用时被一个线程改变，从而违反了线程安全。当编写非线程安全的代码时，实际上会出现一系列更基本的问题，但以上只是一个稍微做作的例子。

但是，您可以通过向第一个 async 调用添加“捕获列表”来表明您想要使用原始 employees 数组的副本:

queue.async { [employees] in
    ...
}

或者，如果您将此值类型作为参数传递给另一个方法，您将自动获得此行为:

doSomethingAsynchronous(with: employees) { result in
    ...
}

在这两种情况中的任何一种情况下，您都会享受值语义并看到原始数组的副本(或写时复制)，尽管原始数组可能已在其他地方发生了变化。

归根结底，我的观点只是值类型不能保证每个线程都有自己的副本。 Array 类型不是(许多其他可变值类型也是)线程安全的。但是，与所有值类型一样，Swift 提供了简单的机制(其中一些是完全自动和透明的)，可以为每个线程提供自己的副本，从而更容易编写线程安全的代码。

---

这是另一个值类型的示例，它使问题更加明显。这是一个示例，其中未能编写线程安全代码会返回语义上无效的对象:

let queue = DispatchQueue.global()

struct Person {
    var firstName: String
    var lastName: String
}

var person = Person(firstName: "Rob", lastName: "Ryan")

queue.async {
    Thread.sleep(forTimeInterval: 0.5)
    print("1: \(person)")
}

queue.async { 
    person.firstName = "Rachel"
    Thread.sleep(forTimeInterval: 1)
    person.lastName = "Moore"
    print("2: \(person)")
}

在这个例子中，第一个打印语句实际上是“Rachel Ryan”，它既不是“Rob Ryan”也不是“Rachel Moore”。简而言之，我们正在检查处于内部不一致状态的 Person。

但是，同样，我们可以使用捕获列表来享受值语义:

queue.async { [person] in
    Thread.sleep(forTimeInterval: 0.5)
    print("1: \(person)")
}

在这种情况下，它会说“Rob Ryan”，而没有注意到原来的 Person 可能正处于被另一个线程变异的过程中。 (显然，仅通过在第一个 async 调用中使用值语义并不能解决真正的问题，而是要同步第二个 async 调用和/或在那里使用值语义。 )