Multithreading 向服务器重复异步请求

我想做的是一遍又一遍地异步地重复对服务器的GET请求，以便能够将本地数据与远程数据同步。我想通过使用

Future

s来做到这一点，而不涉及akka，因为我只想了解如何在较低级别上做到这一点的基本思想。无

async

和

wait

这两种方法都是可取的，因为它们是

期货

和

承诺

的高级函数，所以我想使用

期货

和

承诺

本身

这就是我的功能：

def sendHttpRequestToServer(): String = { ... }

def send: Unit = {
  val f = future { sendHttpRequestToServer() }
  f onComplete {
    case Success(x) => 
      processResult(x)      // do something with result "x"
      send                  // delay if needed and send the request again
    case onFailure(e) =>
      logException(e)
      send                  // send the request again
  }  
}

我想可能就是这样。我怎样才能改变它，算法有错误吗？你的想法

更新：

---

正如我已经知道的，未来不是为重复性任务而设计的，只是为一次性任务而设计的。因此，它们不能在这里使用。那么我使用什么呢？

您的代码在异常处理方面存在一些问题。如果在

processResult

或

logException

中引发异常，

send

将不再发生，从而中断循环。也不会记录此异常。更好的方法是：

f.map(processResult).onFailure(logException)
f.onComplete(x => send())

这样，尽管在

processResult

或

logException

中出现异常，

processResult

中的异常会被记录下来，并且下一次发送可以在处理结果的过程中中间开始。如果要等待处理完成，可以执行以下操作：

val f2 = f.map(processResult).recover { case e => logException(e) }
f2.onComplete(x => send())

---

您的代码在异常处理方面存在一些问题。如果在

processResult

或

logException

中引发异常，

send

将不再发生，从而中断循环。也不会记录此异常。更好的方法是：

f.map(processResult).onFailure(logException)
f.onComplete(x => send())

这样，尽管在

processResult

或

logException

中出现异常，

processResult

中的异常会被记录下来，并且下一次发送可以在处理结果的过程中中间开始。如果要等待处理完成，可以执行以下操作：

val f2 = f.map(processResult).recover { case e => logException(e) }
f2.onComplete(x => send())

---

您的代码在异常处理方面存在一些问题。如果在

processResult

或

logException

中引发异常，

send

将不再发生，从而中断循环。也不会记录此异常。更好的方法是：

f.map(processResult).onFailure(logException)
f.onComplete(x => send())

这样，尽管在

processResult

或

logException

中出现异常，

processResult

中的异常会被记录下来，并且下一次发送可以在处理结果的过程中中间开始。如果要等待处理完成，可以执行以下操作：

val f2 = f.map(processResult).recover { case e => logException(e) }
f2.onComplete(x => send())

---

您的代码在异常处理方面存在一些问题。如果在

processResult

或

logException

中引发异常，

send

将不再发生，从而中断循环。也不会记录此异常。更好的方法是：

f.map(processResult).onFailure(logException)
f.onComplete(x => send())

这样，尽管在

processResult

或

logException

中出现异常，

processResult

中的异常会被记录下来，并且下一次发送可以在处理结果的过程中中间开始。如果要等待处理完成，可以执行以下操作：

val f2 = f.map(processResult).recover { case e => logException(e) }
f2.onComplete(x => send())

---

但如何知道processResult和logException是否已尝试。。。到底有没有拦路？我没有。这样我就不必知道，processResult也不需要自己单独的try/catch/call来调用

logException

，所以代码就比较枯燥了。我不认为如果processResult和logException没有try。。。接着是代码烘干机。为什么这样认为？因为您将在多个位置重复异常处理逻辑

processResult

将需要一个try/catch块调用

logException

，而像我上面所做的那样，将所有异常汇集到一个调用

logException

的单个调用中是很困难的。但是您如何知道processResult和logException是否已尝试过。。。到底有没有拦路？我没有。这样我就不必知道，processResult也不需要自己单独的try/catch/call来调用

logException

，所以代码就比较枯燥了。我不认为如果processResult和logException没有try。。。接着是代码烘干机。为什么这样认为？因为您将在多个位置重复异常处理逻辑

processResult

将需要一个try/catch块调用

logException

，而像我上面所做的那样，将所有异常汇集到一个调用

logException

的单个调用中是很困难的。但是您如何知道processResult和logException是否已尝试过。。。到底有没有拦路？我没有。这样我就不必知道，processResult也不需要自己单独的try/catch/call来调用

logException

，所以代码就比较枯燥了。我不认为如果processResult和logException没有try。。。接着是代码烘干机。为什么这样认为？因为您将在多个位置重复异常处理逻辑

processResult

将需要一个try/catch块调用

logException

，而像我上面所做的那样，将所有异常汇集到一个调用

logException

的单个调用中是很困难的。但是您如何知道processResult和logException是否已尝试过。。。到底有没有拦路？我没有。这样我就不必知道，processResult也不需要自己单独的try/catch/call来调用

logException

，所以代码就比较枯燥了。我不认为如果processResult和logException没有try。。。接着是代码烘干机。为什么这样认为？因为您将在多个位置重复异常处理逻辑

processResult

需要一个try/catch块调用

logException

，而像我上面所做的那样，将所有异常导入到一个调用

logException

。