Fatal编程技术网
  • java/
  • Java 列表扩展的增量未来

Java 列表扩展的增量未来

java concurrency

Java 列表扩展的增量未来,java,concurrency,future,Java,Concurrency,Future,我基本上有一个未来，它是从服务器批量获取的。对于一些客户，我希望在未来完成时，在加载整个集合的同时提供增量结果 是否有一个共同的未来扩展定义的地方？这些期货的典型模式/组合是什么 我假设给定的IncrementalListFuture我可以轻松定义map操作。你还想到了什么 是否有一个共同的未来扩展定义的地方 我假设您谈论的是来自ExecutorService的增量结果。你应该考虑使用一个允许你在“未来< /Cord>”对象中得到通知的对象。< /P> 引用javadocs： Completio

我基本上有一个
未来
，它是从服务器批量获取的。对于一些客户，我希望在未来完成时，在加载整个集合的同时提供增量结果

是否有一个共同的未来扩展定义的地方？这些期货的典型模式/组合是什么

我假设给定的
IncrementalListFuture
我可以轻松定义
map
操作。你还想到了什么

是否有一个共同的未来扩展定义的地方

我假设您谈论的是来自
ExecutorService
的增量结果。你应该考虑使用一个允许你在“<代码>未来< /Cord>”对象中得到通知的对象。< /P> 引用javadocs：

CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
for (Callable<Result> s : solvers) {
    ecs.submit(s);
}
int n = solvers.size();
for (int i = 0; i < n; ++i) {
    // this waits for one of the futures to finish and provide a result
    Future<Result> future = ecs.take();
    Result result = future.get();
    if (result != null) {
        // do something with the result
    }
}
您还可以使用某种类型的
SomeJob.take（）
方法，该方法调用在job类中定义的
BlockingQueue

// the blocking queue in this case is hidden inside your job object
T result = someJob.take();
...
是否有一个共同的未来扩展定义的地方

我假设您谈论的是来自
ExecutorService
的增量结果。你应该考虑使用一个允许你在“<代码>未来< /Cord>”对象中得到通知的对象。< /P> 引用javadocs：

CompletionService<Result> ecs = new ExecutorCompletionService<Result>(e);
for (Callable<Result> s : solvers) {
    ecs.submit(s);
}
int n = solvers.size();
for (int i = 0; i < n; ++i) {
    // this waits for one of the futures to finish and provide a result
    Future<Result> future = ecs.take();
    Result result = future.get();
    if (result != null) {
        // do something with the result
    }
}
您还可以使用某种类型的
SomeJob.take（）
方法，该方法调用在job类中定义的
BlockingQueue

// the blocking queue in this case is hidden inside your job object
T result = someJob.take();
...
下面是我要做的：

  • 在填充列表的线程中，通过使用
    Collections.synchronizedList
  • 通过向返回列表的线程添加一个public方法，使列表公开可用，但不可修改，该线程由
    集合包装。不可修改列表
  • 与其给客户机一个Future>，不如给他们一个线程句柄或它的某种包装器，这样他们就可以调用上面的public方法
    • 或者，正如格雷所建议的，
    BlockingQueue
    s非常适合这样的线程协调。但是，这可能需要对客户端代码进行更多更改。

    以下是我要做的：

  • 在填充列表的线程中，通过使用
    Collections.synchronizedList
  • 通过向返回列表的线程添加一个public方法，使列表公开可用，但不可修改，该线程由
    集合包装。不可修改列表
  • 与其给客户机一个Future>，不如给他们一个线程句柄或它的某种包装器，这样他们就可以调用上面的public方法
    • 或者，正如格雷所建议的，
    BlockingQueue
    s非常适合这样的线程协调。但是，这可能需要对客户端代码进行更多更改。

    Future实际上是为了返回单个（原子）结果而设计的，而不是为了以这种方式传递中间结果。您真正想要做的是使用多个期货，每批一个

    我们有一个类似的需求，我们需要从不同的远程服务器获取大量的东西，并且每个东西都会在不同的时间返回。我们不想等到最后一个返回，而是按照返回的顺序处理它们。为此，我们创建了，它接受一个
    Iterable
    ，并返回一个
    Iterable
    ，在迭代时阻塞，完全抽象了
    未来
    接口的用法

    如果您了解该类是如何实现的，您将了解如何使用
    CompletionService
    从
    Executor
    接收结果（如果您需要自己构建该类），并按照它们的可用顺序进行

    编辑：刚刚看到Gray的回答的后半部分是类似的，基本上使用ExecutorCompletionService，Future的设计目的是返回单个（原子）结果，而不是以这种方式传递中间结果。您真正想要做的是使用多个期货，每批一个

    我们有一个类似的需求，我们需要从不同的远程服务器获取大量的东西，并且每个东西都会在不同的时间返回。我们不想等到最后一个返回，而是按照返回的顺序处理它们。为此，我们创建了，它接受一个
    Iterable
    ，并返回一个
    Iterable
    ，在迭代时阻塞，完全抽象了
    未来
    接口的用法

    如果您了解该类是如何实现的，您将了解如何使用
    CompletionService
    从
    Executor
    接收结果（如果您需要自己构建该类），并按照它们的可用顺序进行

    编辑：刚刚看到格雷的下半部分答案是类似的，基本上是使用ExecutorCompletionService来回答我自己的问题：最近这方面有了很多发展。其中最常用的是：Play iteratees（）和Rx for.NET（）

    他们定义的不是未来，而是：

    interface Observable<T> {
    Disposable subscribe(Observer<T> observer);
}

interface Observer<T> {
   void onCompleted();
   void onError(Exception error);
   void onNext(T value);
}

    可观察的接口{
（观察员）；
}
界面观察者{
无效未完成（）；
无效错误（异常错误）；
void onNext（T值）；
}
    还有很多组合器。

    回答我自己的问题：最近在这个领域有了很多发展。其中最常用的是：Play iteratees（）和Rx for.NET（）

    他们定义的不是未来，而是：

    interface Observable<T> {
    Disposable subscribe(Observer<T> observer);
}

interface Observer<T> {
   void onCompleted();
   void onError(Exception error);
   void onNext(T value);
}

    可观察的接口{
（观察员）；
}
界面观察者{
无效未完成（）；
无效错误（异常错误）；
void onNext（T值）；
}
    还有很多组合词。

    除了可观察的，你还可以看看twitter的方法

    它们使用，这是的异步版本

    基本上，这是一个简单的特征，类似于
    列表

    trait Spool[+A] {

  def head: A

  /**
   * The (deferred) tail of the spool. Invalid for empty spools.
   */
  def tail: Future[Spool[A]]
}