如何在装饰器类中拦截和处理 Future？

Question

我正在装饰一个类，其中一些方法返回一个 Future。在一种特定情况下，我对 Future 的结果感兴趣，并想在通知调用者之前拦截它。也许是这样的：

public Future<Integer> getCalculation() {
  Future<Integer> future = realObject.getCalculation();
  // Get the result, store it somewhere
  // ???
}

如果 getCalculation 是同步的，我可以调用 realObject，等待响应，对它做任何我想做的事情，然后简单地返回它，如下所示：

public int getCalculation() {
  int result = realObject.getCalculation();
  this.cache = result;
  return result;
}

如何将此模式应用于返回 Future 的东西？

Answer 1

来自 Guava 库的SettableFuture 可能会派上用场： http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/util/concurrent/SettableFuture.html

您确实可以创建一个SettableFuture 并为其分配您的直接价值。

Answer 2

如何将此模式应用于返回 Future 的东西？

我认为你必须在这里实现自己的代理Future 类。可能类似于以下委托给代理的内容：

public class FutureProxy implements Future<Integer> {
    private Calculator calculator;
    private Future<Integer> delegate;
    public FutureProxy(Calculator calculator, Future<Integer> delegate) {
        this.calculator = calculator;
        this.delegate = delegate;
    }
    // proxy all of the methods
    public boolean isDone() {
        return delegate.isDone();
    }
    ...
    // for get, you can then call back to `calculator`
    public Integer get() throws InterruptedException, ExecutionException {
        Integer result = delegate.get();
        calculator.setCachedCalculation(result);
        return result;
    }
    // need to handle get(long, TimeUnit) as well
    public Integer get(long timeout, TimeUnit unit)
          throws InterruptedException, ExecutionException, TimeoutException;
        Integer result = delegate.get(timeout, unit);
        calculator.setCachedCalculation(result);
        return result;
    }
}

那么你的装饰器吸气剂看起来像：

public Future<Integer> getCalculation() {
   Future<Integer> future = realObject.getCalculation();
   return new FutureProxy(this, future);
}

正如您在 cmets 中提到的，如果 FutureProxy 是装饰器的内部类，则不会注入 Calculator。如果代理正在更新 Calculator 中将被其他线程访问的字段，请确保您使用 volatile 字段。

Answer 3

在这种情况下，你的方法必须阻塞...

public Future<Integer> getCalculation() {
  Future<Integer> future = realObject.getCalculation();

  // Get the result, store it somewhere
  //the .get() method is blocking...
  myInteger = future.get();

  return future;
}

调用者代码会立即成功get()-ting结果...

编辑

如果需要非阻塞，为将来创建一个包装类

FutureWrapper<T> implements Future<T> {

    Future<T> wrapped;
    public FutureWrapper(Future<T> toBeWrapped) {
        wrapped = toBeWrapped;
    }

    public T get() {
        return wrapped.get();
    }

    //the other wrapper methods left out for sake of clarity
}


MyWrapper extends FutureWrapper<Integer>{

    //100% boilerplate
    public MyWrapper(Future<Integer> toBeWrapped) {
        super(toBeWrapped);
    }

    @Override
    public Integer get() {
        Integer value = super.get();
        //do the dirty stuff
        return value;
    }

}

EDIT2

如果“肮脏的东西”涉及抚摸装饰器的隐私（对不起，不是英语母语:)（双关语），您可以在装饰器类中定义 MyWrapper 类：

public MyDecorator {

    Integer dirtyStuff;


    public class MyWrapper extends FutureWrapper<Integer>{
        //boilerplate omitted
        public Integer get() {
            dirtyStuff= super.get();
            return dirtyStuff;
        }
}

Answer 4

您将要使用从装饰器返回的代理 Future。然后，您需要实现代理 Future 的 #get 方法来阻止，直到真正的 Future 返回，并且您已经能够对结果执行您的工作。

class ProxyFuture<T> implements Future<T> {

    private Future<T> original;
    private Task task;
    ExecutorService executor;

    public ProxyFuture(Future<T> original, Runnable task, ExecutorService executor) {
        this.original = original;
        this.task = task;
        this.executor = executor;
    }

    public T get() throws InterruptedException, ExecutionException {
        T result = original.get();
        executor.execute(task);
        return result;
    }


}

在这里，您有一些用于 ExecutorService 的应用程序资源，并让您的 Decorator 创建一个 Runnable 并将其传递给新的 Future。这样，您的 ProxyFuture 将在将结果传递回原始请求者之前调用装饰器中的代码。

以下是装饰器示例

public class Decorator {

    Object original;

    public Decorator(Object original){
        this.original = original;
    }

    public void doDecoratedBehavior(){

    }

    public Runnable createTask(){
        return new Runnable(){
            public void run(){
                doDecoratedBehavior();
            }
        };
    }
}

Answer 5

根据您的描述，您的异步是毫无意义的。这是我对您所要求的内容的伪代码解释 -

Future<Integer> getCalculation(){
    Future<Integer> future = realObject.getCalculation();
    //asynch code runs while you presumably do other stuff.
    ....
    ....
    result = future.get();
    return future;
}

但在这一点上，使用未来是没有意义的。异步为您节省了no 时间。事实上，由于额外的开销，它实际上使事情花费了更长。这是因为当您执行result = future.get() 时，您会等待线程完成，从而丢失您节省的所有时间。这也意味着返回未来没有任何优势，因为它除了result之外什么也做不了。

换句话说，这段代码会更快，更省事（假设你在计算过程中不需要做任何事情）-

Integer getCalculation(){
    return realObject.getCalculation();//assume it is rewritten to just return an int.
}