Question

我有一组任务，我想在一些后台线程中按顺序执行，每个任务的结果都传递给下一个，如果链中的任何链接都失败，链失败。

为了论证，让我们说每个任务都是一个带有exec方法的对象，它返回一个值，尽管它们同样可以是procs或lambdas。

我现在拥有的是：

promise = array_of_tasks.inject(nil) do |promise, task|
            if promise
              promise.then { |prev_result| task.exec(prev_result) }
            else
              Concurrent::Promise.new { task.exec }
            end
          end

promise.on_success { |last_result| log.info("Success: #{last_result} ")}
promise.rescue { |reason| log.error("Failure: #{reason}")}

是否有更简洁的方法可以在Promise API或Concurrent Ruby中的其他地方执行此操作？这似乎是一个相当基本的操作，但我没有看到现有的方法。

（旁注：如果没有这样的方法，在期货和承诺的世界中，这个模式是否有一个众所周知的名称？即，如果我自己编写方法，是否存在一些显而易见的名字？）

Answer 1

它不短，但这种结构可能更容易添加新功能：

require 'concurrent'

class Task
  def exec(x = 0)
    sleep 0.1
    p x + 1
  end

  alias call exec

  def to_promise(*params)
    Concurrent::Promise.new { exec(*params) }
  end
end

module PromiseChains
  refine Concurrent::Promise do
    def chained_thens(callables)
      callables.inject(self) do |promise, callable|
        promise.then do |prev_result|
          callable.call(prev_result)
        end
      end
    end
  end
end

可以这样使用：

using PromiseChains

array_of_tasks = Array.new(10) { Task.new } 

array_of_tasks << ->(x) { p x * 2 } 
array_of_tasks << proc { |x| p x * 3 }

first_task, *other_tasks = array_of_tasks

chain = first_task.to_promise.chained_thens(other_tasks)

chain.on_success { |last_result| puts "Success: #{last_result} " }
chain.rescue { |reason| puts "Failure: #{reason}" }

chain.execute
sleep(2)

输出：

1
2
3
4
5
6
7
8
9
10
20
60
Success: 60

在Concurrent Ruby中链接一系列任务

1 个答案: