Swift 命令行工具中的多个工作人员

Question

在 Swift 中编写命令行工具 (CLT) 时，我想处理大量数据。我已经确定我的代码受 CPU 限制，并且性能可以从使用多个内核中受益。因此，我想并行化部分代码。假设我要实现以下伪代码：

Fetch items from database
Divide items in X chunks
Process chunks in parallel
Wait for chunks to finish
Do some other processing (single-thread)

现在我一直在使用 GCD，一个幼稚的方法看起来像这样：

let group = dispatch_group_create()
let queue = dispatch_queue_create("", DISPATCH_QUEUE_CONCURRENT)
for chunk in chunks {
    dispatch_group_async(group, queue) {
        worker(chunk)
    }
}
dispatch_group_wait(group, DISPATCH_TIME_FOREVER)

但是 GCD 需要一个运行循环，因此代码将挂起，因为该组永远不会执行。 runloop 可以用dispatch_main() 启动，但它永远不会退出。也可以在几秒钟内运行NSRunLoop，但这并不是一个可靠的解决方案。不考虑 GCD，用 Swift 怎么实现呢？

Answer 1

我错误地将锁定线程解释为挂起程序。没有运行循环，这项工作将执行得很好。问题中的代码将运行良好，并阻塞主线程，直到整个组完成。

假设chunks 包含 4 项工作负载，以下代码启动 4 个并发工作人员，然后等待所有工作人员完成：

let group = DispatchGroup()
let queue = DispatchQueue(label: "", attributes: .concurrent)

for chunk in chunk {
    queue.async(group: group, execute: DispatchWorkItem() {
        do_work(chunk)
    })
}

_ = group.wait(timeout: .distantFuture)

Answer 2

就像使用 Objective-C CLI 一样，您可以使用 NSRunLoop 创建自己的运行循环。

这是一种可能的实现，以 this gist 为模型：

class MainProcess {
    var shouldExit = false

    func start () {
        // do your stuff here
        // set shouldExit to true when you're done
    }
}

println("Hello, World!")

var runLoop : NSRunLoop
var process : MainProcess

autoreleasepool {
    runLoop = NSRunLoop.currentRunLoop()
    process = MainProcess()

    process.start()

    while (!process.shouldExit && (runLoop.runMode(NSDefaultRunLoopMode, beforeDate: NSDate(timeIntervalSinceNow: 2)))) {
        // do nothing
    }
}

正如 Martin 指出的那样，您可以使用 NSDate.distantFuture() as NSDate 而不是 NSDate(timeIntervalSinceNow: 2)。 （强制转换是必要的，因为distantFuture() 方法签名表明它返回AnyObject。）

如果您需要访问 CLI 参数 see this answer。你也可以return exit codes using exit()。

Answer 3

Aaron Brager 解决方案的 Swift 3 最小实现，它简单地结合了 autoreleasepool 和 RunLoop.current.run(...) 直到你打破循环：

var shouldExit = false
doSomethingAsync() { _ in
    defer {
        shouldExit = true
    }
}
autoreleasepool {
    var runLoop = RunLoop.current
    while (!shouldExit && (runLoop.run(mode: .defaultRunLoopMode, before: Date.distantFuture))) {}
}

Answer 4

在这种情况下，我认为CFRunLoop 比NSRunLoop 容易得多

func main() {
    /**** YOUR CODE START **/
    let group = dispatch_group_create()
    let queue = dispatch_queue_create("", DISPATCH_QUEUE_CONCURRENT)
    for chunk in chunks {
        dispatch_group_async(group, queue) {
            worker(chunk)
        }
    }
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER)
    /**** END **/
}


let runloop = CFRunLoopGetCurrent()
CFRunLoopPerformBlock(runloop, kCFRunLoopDefaultMode) { () -> Void in
    dispatch_async(dispatch_queue_create("main", nil)) {
        main()
        CFRunLoopStop(runloop)
    }
}
CFRunLoopRun()