基于Scala的并行计算_Scala_User Defined Functions_Future_Scala Collections_Futuretask

基于Scala的并行计算

scala

基于Scala的并行计算,scala,user-defined-functions,future,scala-collections,futuretask,Scala,User Defined Functions,Future,Scala Collections,Futuretask,我有一个计算两个子函数的函数，就像这样 def someFutureMethod1(input: Int): Int = { input + 1 } def someFutureMethod2(input: Int): Int = { input + 12 } def method1(sx: Int): Future[Int] = Future { val future: Int = someFutureMethod1(sx)

我有一个计算两个子函数的函数，就像这样

def someFutureMethod1(input: Int): Int = {
      input + 1
    }

def someFutureMethod2(input: Int): Int = {
      input + 12
    }

def method1(sx: Int): Future[Int] = Future {

      val future: Int = someFutureMethod1(sx)
      val future2: Int = someFutureMethod2(future)

future.andThen{
return future
}
future2.andThen{
return future2
}


}

Print(method1(10))


expected result:
11
23

我想在计算第一个函数后立即返回结果，并在计算第二个函数时更新或附加到相同的结果

第二个函数依赖于第一个函数。一旦第一个函数成功执行，它将返回结果。第一函数结果被传递给第二函数以计算第二函数。如果计算了第二个函数，则仅返回第二个函数结果

有没有办法做到这一点

提前谢谢

检查此代码段（有函数签名修改）

导入scala.concurrent.Future
导入scala.concurrent.ExecutionContext.Implicits.global
def someFutureMethod1（输入：Int）：Future[Int]=Future{
输入+1
}
def someFutureMethod2（输入：Int）：Future[Int]=Future{
输入+12
}
def method1（sx:Int）：未来[Int]={
val future1=某些未来方法1（sx）
val future2=某些未来方法2（sx）
为了{
f1好的，你可以这样做：
implicit val ec = Implicits.global

  def someFutureMethod1(input: AtomicInteger): Unit = {
    Future {
      input.addAndGet(1)
      println(input + " after method 1. And maybe also after method 2, because who knows.")
    }
  }

  def someFutureMethod2(input: AtomicInteger): Unit = {
    Future {
      input.addAndGet(12)
      println(input + " after method 2. And maybe also after method 1...")
    }
  }

  val at = new AtomicInteger(1)
  someFutureMethod1(at)
  someFutureMethod2(at)
  println(at + " at any point before or after the futures, so a pretty random value.")
  Thread.sleep(1000)
  println(at + " after all the futures. Probably.")

我添加了所有的println，这样代码就可以复制粘贴并运行了。每次运行它时，它都会产生不同的输出，这应该是你想要运行并逃离的线索
我不会在我管理的任何代码库中接受这段代码，我甚至不会在POC中接受它。这是完全不可预测的。基本上，method1和method2中的4条指令可以以任何顺序执行
还请注意，它并不保证首先执行method1
如果需要，可以这样更改代码，以确保在调用第二个方法之前解决了第一个问题：
  //Fluff removed

  def someFutureMethod1(input: AtomicInteger): Future[Unit] = {
    Future {
      input.addAndGet(1)
    }
  }

  def someFutureMethod2(input: AtomicInteger): Future[Unit] = {
    Future {
      input.addAndGet(12)
    }
  }

  def theUglyMethod(at: AtomicInteger) = someFutureMethod1(at).map {_ =>
    someFutureMethod2(at)
    at
  }

再一次，请不要这样做！^^
AFuture
已完成一个值，或者它仍在处理该值。一个或另一个（或者它已失败）我认为获得你想要的东西的唯一方法是让每个Future
在完成时修改相同的var
变量。非常危险。非常糟糕的主意。可能是重复的。你不能使用Scala async来获得你想要的吗？甚至可能是Scala任务也会有帮助！你能确切地解释一下为什么会发生这种更新，以及如何发生这种更新吗？如果其他Future在第二个方法完成时已经使用了第一个返回值，该怎么办？这确实不能回答返回第一个结果然后用第二个结果更新它的问题。我认为在这段代码中，我们不会在计算时立即返回。我们正在等待第二个Future计算，然后返回.@Learnis；不是这样。method1（）
不会等待。它会立即返回，但会返回一个可能/可能尚未完成的未来的结果。@jwvh问题是，此代码不会返回OP要求的method1的结果，它只返回method2的结果。不清楚“返回”是什么问题中的意思，但想法是返回第一个方法的结果，然后在第二个方法可用时将其更新为第二个方法的结果。@Tim；同意。此代码不满足OP的要求，同意OP通过“返回”的意思不清楚。事实上，我认为这个问题的最新编辑将水弄得更加浑浊。但是method1（）
返回两个someFutureMethod
的总和，包装在Future
中。那么OP是否曲解了代码，或者只是描述得很差？很难说。这样做很好。我想要的是部分返回响应。我不明白，您正在正确计算方法someFutureMethod1和someFutureMethod2。？在t中方法someFutureMethod1计算完成后，将结果交给被调用的方法1，方法someFutureMethod2应计算其任务并将结果附加到旧结果中。您可以根据需要重新获得方法签名，此时这是一个实现细节，您必须适应您自己的实际情况（我想这并不是在加整数）我不认为重新编写代码就能解决这个问题