arrays - Swift 中的多线程函数式编程

Question

我最近一直在 Swift 2.1 中操作字节数组，我经常发现自己写的代码是这样的:

// code to add functions to a [UInt8] object
extension CollectionType where Generator.Element == UInt8 {

    func xor(with byte: UInt8) -> [UInt8] {
        return map { $0 ^ byte }
    }
}

// example usage: [67, 108].xor(with: 0) == [67, 108]

是否有一种简单的方法来并行化此 map 调用，以便多个线程可以同时对数组的非重叠区域进行操作？

我可以编写代码来手动将数组划分为子数组，并在不同的线程中对每个子数组调用 map。但我想知道 Swift 中是否存在某些框架来自动进行除法，因为 map 是一个函数调用，可以在线程安全的环境中工作而没有副作用。

澄清说明:

1. 代码只需要在一个[UInt8]对象上工作，不一定是每个CollectionType。

Answer 1

并行执行计算循环的最简单方法是 concurrentPerform(以前称为 dispatch_apply ；请参阅 并发编程指南 中的 Performing Loop Iterations Concurrently)。但是，不，没有可以为您执行此操作的 map 再现。你必须自己做。

例如，您可以编写一个扩展来执行并发任务:

extension Array {
    public func concurrentMap<T>(_ transform: (Element) -> T) -> [T] {
        var results = [Int: T](minimumCapacity: count)

        let lock = NSLock()

        DispatchQueue.concurrentPerform(iterations: count) { index in
            let result = transform(self[index])
            lock.synchronized {
                results[index] = result
            }
        }

        return (0 ..< results.count).compactMap { results[$0] }
    }
}

在哪里

extension NSLocking {
    func synchronized<T>(block: () throws -> T) rethrows -> T {
        lock()
        defer { unlock() }
        return try block()
    }
}

您可以使用任何您想要的同步机制(锁、串行队列、读写器)，但我们的想法是并发执行transform，然后同步集合的更新。

注意:

• 这将阻塞您从中调用它的线程(就像非并发 map 一样)，因此请确保将其分派(dispatch)到后台队列。

• 需要确保每个线程上都有足够的工作来证明管理所有这些线程的固有开销是合理的。 (例如，每个循环一个简单的 xor 调用是不够的，你会发现它实际上比非并发再现慢。)在这些情况下，确保你跨步(参见 Improving Loop Code 平衡每个并发的工作量堵塞)。例如，与其对一个极其简单的操作进行 5000 次迭代，不如对每个循环进行 500 次操作的 10 次迭代。您可能需要尝试使用合适的步幅值。

---

虽然我怀疑您不需要此讨论，但对于不熟悉 concurrentPerform(以前称为 dispatch_apply)的读者，我将在下面说明其用法。有关该主题的更完整讨论，请参阅上面的链接。

例如，让我们考虑一些比简单的 xor 复杂得多的东西(因为对于如此简单的东西，开销超过了获得的任何性能)，例如简单的 Fibonacci 实现:

func fibonacci(_ n: Int) -> Int {
    if n == 0 || n == 1 {
        return n
    }
    return fibonacci(n - 1) + fibonacci(n - 2)
}

如果您有一个 array 要计算的 Int 值，而不是:

let results = array.map { fibonacci($0) }

你可以:

var results = [Int](count: array.count, repeatedValue: 0)
DispatchQueue.concurrentPerform(iterations: array.count) { index in
    let result = self.fibonacci(array[index])
    synchronize.update { results[index] = result }      // use whatever synchronization mechanism you want
}

或者，如果你想要一个功能性的再现，你可以使用我在上面定义的extension:

let results = array.concurrentMap { fibonacci($0) }

---

有关 Swift 2 版本，请参阅 previous revision of this answer .