swift – 使用Vapor 3创建和使用游标

@H_404_13@while ... { ... try connection.raw("...").all(decoding: RecRegAction.self).wait() ... }

你想等待一些结果,因此你使用while循环和.wait()来获得所有中间结果.本质上,这是在事件循环中将异步代码转换为同步@L_674_32@.这可能会导致死锁,并且肯定会阻止其他连接,这就是为什么SwiftNIO会尝试检测到并导致@L_450_11@的原因.我不会详细说明为什么它会阻止其他连接,或者为什么这可能会导致这个答案陷入僵局.

让我们看看我们有什么选择来解决这个问题：

>正如你所说,我们可以在另一个不是事件循环线程之一的线程上使用.wait().对于这个任何非EventLoop线程会这样做：DispatchQueue或你可以使用BlockingIOThreadPool(它不在EventLoop上运行)
>我们可以将您的@L_674_32@重写为异步

两种解决方案都可以工作,但(1)实际上并不可取,因为您只需要等待结果就可以刻录整个(内核)线程.并且Dispatch和BlockingIOThreadPool都有他们愿意产生的有限数量的线程,所以如果你经常这样做,你可能会耗尽线程,所以它需要更长的时间.

因此,让我们看看如何在累积中间结果的同时多次调用异步函数.然后,如果我们累积了所有中间结果,则继续所有结果.

为了简化操作,让我们看看与您的功能非常相似的功能.我们假设这个函数就像你的@L_674_32@一样提供

@H_404_13@/// delivers partial results (Integers) and `nil` if no further elements are available func deliverPartialResult() -> EventLoopFuture<Int?> { ... }

我们现在想要的是一个新功能

@H_404_13@func deliverFullResult() -> EventLoopFuture<[Int]>

请注意deliverPartialResult每次返回一个整数,deliverFullResult传递一个整数数组(即所有整数).好的,那么我们如何编写deliverFullResult而不调用deliverPartialResult().wait()？

那这个呢：

@H_404_13@func accumulateResults(eventLoop: EventLoop,partialResultsSoFar: [Int],getPartial: @escaping () -> EventLoopFuture<Int?>) -> EventLoopFuture<[Int]> { // let's run getPartial once return getPartial().then { partialResult in // we got a partial result,let's check what it is if let partialResult = partialResult { // another intermediate results,let's accumulate and call getPartial again return accumulateResults(eventLoop: eventLoop,partialResultsSoFar: partialResultsSoFar + [partialResult],getPartial: getPartial) } else { // we've got all the partial results,yay,let's fulfill the overall future return eventLoop.newSucceededFuture(result: partialResultsSoFar) } } }

鉴于accumulateResults,实现deliverFullResult不再太难了：

@H_404_13@func deliverFullResult() -> EventLoopFuture<[Int]> { return accumulateResults(eventLoop: myCurrentEventLoop,partialResultsSoFar: [],getPartial: deliverPartialResult) }

但让我们更多地了解accumulateResults的作用：

>它调用getPartial一次,然后调用它
>检查我们是否有

>部分结果,在这种情况下,我们将记住它与其他partialResultsSoFar并返回(1)
> nil,这意味着partialResultsSoFar就是我们得到的所有东西,我们回归到了一个新的成功未来

那已经是真的了.我们在这里做的是将同步循环转换为异步递归.

好的,我们查看了很多@L_674_32@,但这与你的功能现在有什么关系？

信不信由你,但这实际上应该有效(未经测试)：

@H_404_13@accumulateResults(eventLoop: el,partialResultsSoFar: []) { connection.raw("FETCH \(chunkSizE) FROM \(cursorName)") .all(decoding: RecRegAction.self) .map { results -> Int? in if results.count > 0 { return results.count } else { return nil } } }.map { allResults in return allResults.reduce(0,+) }

所有这些的结果将是EventLoopF​​uture< Int>它携带所有中间result.count的总和.

当然,我们首先将所有计数收集到一个数组中,然后在最后总结它(allResults.reduce(0,)),这有点浪费但也不是世界末日.我这样离开它是因为这使得accumulateResults可用于你想在数组中累积部分结果的其他情况.

现在最后一件事,一个真正的accumulateResults函数可能在元素类型上是通用的,我们也可以消除外部函数的partialResultsSoFar参数.那这个呢？

@H_404_13@func accumulateResults<T>(eventLoop: EventLoop,getPartial: @escaping () -> EventLoopFuture<T?>) -> EventLoopFuture<[T]> { // this is an inner function just to hide it from the outside which carries the accumulator func accumulateResults<T>(eventLoop: EventLoop,partialResultsSoFar: [T] /* our accumulator */,getPartial: @escaping () -> EventLoopFuture<T?>) -> EventLoopFuture<[T]> { // let's run getPartial once return getPartial().then { partialResult in // we got a partial result,let's check what it is if let partialResult = partialResult { // another intermediate results,let's accumulate and call getPartial again return accumulateResults(eventLoop: eventLoop,getPartial: getPartial) } else { // we've got all the partial results,let's fulfill the overall future return eventLoop.newSucceededFuture(result: partialResultsSoFar) } } } return accumulateResults(eventLoop: eventLoop,getPartial: getPartial) }

编辑：编辑后,您的问题表明您实际上并不想积累中间结果.所以我的猜测是,您希望在收到每个中间结果后进行一些处理.如果这是你想要做的,也许试试这个：

@H_404_13@func processPartialResults<T,V>(eventLoop: EventLoop,process: @escaping (T) -> EventLoopFuture<V>,getPartial: @escaping () -> EventLoopFuture<T?>) -> EventLoopFuture<V?> { func processPartialResults<T,soFar: V?,getPartial: @escaping () -> EventLoopFuture<T?>) -> EventLoopFuture<V?> { // let's run getPartial once return getPartial().then { partialResult in // we got a partial result,let's call the process function and move on return process(partialResult).then { v in return processPartialResults(eventLoop: eventLoop,soFar: v,process: process,getPartial: getPartial) } } else { // we've got all the partial results,let's fulfill the overall future return eventLoop.newSucceededFuture(result: soFar) } } } return processPartialResults(eventLoop: eventLoop,soFar: nil,getPartial: getPartial) }

这将(如前所述)运行getPartial,直到它返回nil,但不是累积所有getPartial的结果,而是调用获得部分结果的进程,并且可以进行一些进一步的处理.当满足EventLoopF​​uture进程返回时,将发生下一个getPartial调用.

那更接近你想要的吗？

注意：我在这里使用了SwiftNIO的EventLoopF​​uture类型,在Vapor中您只需使用Future,但@L_674_32@的其余部分应该相同.