Java 播放框架：处理控制器承诺超时

我的应用程序的所有控制器（Play Framework 2.2.4，Java）都返回一个F。承诺：现在有一个控制器，我可以切换到另一个akka上下文，因为它的计算时间可能更长。上下文切换非常简单，因为您可以使用api：

return F.Promise.promise(...,executionContext)

并在application.conf中配置自定义executionContext。现在问题出现在计算时间比指定的时间长（让我们做20秒）：我不能做出承诺超时。考虑到我不想调用get（20，TimeNo.s）。方法，因为我相信play会尽其所能做到这一点

thread-pool-executor {
    # Keep alive time for threads
    keep-alive-time = 60s

    # Min number of threads to cap factor-based core number to
    core-pool-size-min = 8

    # The core pool size factor is used to determine thread pool core size
    # using the following formula: ceil(available processors * factor).
    # Resulting size is then bounded by the core-pool-size-min and
    # core-pool-size-max values.
    core-pool-size-factor = 3.0

    # Max number of threads to cap factor-based number to
    core-pool-size-max = 64

    # Minimum number of threads to cap factor-based max number to
    # (if using a bounded task queue)
    max-pool-size-min = 8

    # Max no of threads (if using a bounded task queue) is determined by
    # calculating: ceil(available processors * factor)
    max-pool-size-factor  = 3.0

    # Max number of threads to cap factor-based max number to
    # (if using a  bounded task queue)
    max-pool-size-max = 64

    # Specifies the bounded capacity of the task queue (< 1 == unbounded)
    task-queue-size = -1

    # Specifies which type of task queue will be used, can be "array" or
    # "linked" (default)
    task-queue-type = "linked"

    # Allow core threads to time out
    allow-core-timeout = on
  }

线程池执行器{
#保持线程的活动时间
保持活动时间=60秒
#最小线程数以cap因子为基础的核心数
核心池大小最小值=8
#核心池大小因子用于确定线程池核心大小
#使用以下公式：ceil（可用处理器*系数）。
#然后，结果大小由核心池大小min和
#核心池大小最大值。
核心池大小系数=3.0
#要限制的最大线程数基于要限制的线程数的系数
核心池最大大小=64
#最小线程数到cap因子基于最大线程数到
#（如果使用有界任务队列）
最大池大小最小值=8
#最大线程数（如果使用有界任务队列）由
#计算：ceil（可用处理器*系数）
最大池大小系数=3.0
#最大线程数到cap基于系数的最大线程数到
#（如果使用有界任务队列）
最大池大小max=64
#指定任务队列的有界容量（<1==无界）
任务队列大小=-1
#指定将使用哪种类型的任务队列，可以是“数组”或
#“链接”（默认）
任务队列类型=“已链接”
#允许核心线程超时
允许核心超时=开启
}

但是无论是保持活动时间还是允许核心超时属性都不适用于超时长计算承诺

我尝试将返回类型更改为：

F.Promise<Result> original = F.Promise.promise(...,customExecutionService);
return F.promise.timeout(original,10,TimeUnit.SECONDS);

F.Promise original=F.Promise.Promise（…，customExecutionService）；
返回F.promise.timeout（原始值，10，时间单位为秒）；

但这只会将执行延迟10秒。（timeout方法文档非常混乱）

我试过的另一个片段是：

F.Promise<Result> original = F.Promise.promise(...,customExecutionService);
  return F.promise.timeout(original,10,TimeUnit.SECONDS).get(10,TimeUnit.SECONDS);

F.Promise original=F.Promise.Promise（…，customExecutionService）；
返回F.promise.timeout（原始，10，TimeUnit.SECONDS），get（10，TimeUnit.SECONDS）；

但这是外部包装器的承诺

---

因此，我现在得出的结论是，我必须编写自己的自定义executionService来设置超时侦听器，并自行抛出TimeoutException，但我确信有一种更简单的方法可以实现这一点。

我通过包装原始响应（不超时的响应）找到了一种解决方案使用以下代码：

Future<T> error = after(Duration.create(delay,unit),Akka.system().scheduler(),main,
                Futures.failed(new TimeoutException("Future timed out")));

return Promise.wrap(Futures.firstCompletedOf(
    Lists.newArrayList(original.wrapped(),error), main));

Future error=after（Duration.create（delay，unit），Akka.system（）.scheduler（），main，
Futures.failed（新的TimeoutException（“未来超时”））；
返回承诺。包装（Futures.firstCompletedOf(
newArrayList（original.wrapped（），error），main）；

```

其中，main是主执行上下文，after取自akka模式。基本上，如果原始承诺花费的时间超过了错误中传递的持续时间，则未来将通过抛出超时异常来生效

---

我把它放在一个过滤器中，这样每个带有该过滤器注释的控制器都有相同的行为。

我找到了一个解决方案，用以下代码包装原始响应（不超时的响应）：

Future<T> error = after(Duration.create(delay,unit),Akka.system().scheduler(),main,
                Futures.failed(new TimeoutException("Future timed out")));

return Promise.wrap(Futures.firstCompletedOf(
    Lists.newArrayList(original.wrapped(),error), main));

Future error=after（Duration.create（delay，unit），Akka.system（）.scheduler（），main，
Futures.failed（新的TimeoutException（“未来超时”））；
返回承诺。包装（Futures.firstCompletedOf(
newArrayList（original.wrapped（），error），main）；

```

其中，main是主执行上下文，after取自akka模式。基本上，如果原始承诺花费的时间超过了错误中传递的持续时间，则未来将通过抛出超时异常来生效

我把它放在一个过滤器中，这样每个带过滤器注释的控制器都有相同的行为