Scala 异步编程之 Future (二)

上篇博客讲了scala中的Future，实际上java 在jdk1.5后增加了callable，也实现了Future，以《Netty In Action》中的代码为例，看一下java中Future的实现：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureViaJdkExample {
    public static void main(String[] args)throws Exception {
        ExecutorService executor = Executors.newCachedThreadPool();
        Runnable task1 = new Runnable() {
            @Override
            public void run() {
                // do some heavy work
                try {
                    Thread.sleep(1000 * 1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        Callable<Integer> task2 = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                // do some heavy work with result
                try {
                    Thread.sleep(1000 * 2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return 0;
            }
        };

        Future<?> future1 = executor.submit(task1);
        Future<Integer> future2 = executor.submit(task2);
        while(!future1.isDone() || !future2.isDone()) {
            System.out.println("do something else...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("future2 value : "+future2.get());
        executor.shutdown();
    }
}

future1是executor提交了runnable的任务，接口如下：

Future<?> submit(Runnable task);

而future2提交了callable的任务

<T> Future<T> submit(Callable<T> task);

submit实现了重载，对于第二种submit的具体实现如下：

    public <T> Future<T> submit(Runnable task, T result) 

{ 

 if (task == null) throw new NullPointerException(); 

 RunnableFuture<T> ftask = newTaskFor(task, result); 

 execute(ftask); 

 return ftask;

 }

RunnableFuture接口继承了Runnable和Future接口，因此我们可以通过run()方法执行callable的代码，通过future获取返回值。

但是java的Future只能通过阻塞等待结果，而scala中的Oncomplete,OnSuccess等回调能充分地利用多核。