Future callback实现

FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果，因此，FutureTask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，FutureTask还可以确保即使调用了多次run方法，它都只会执行一次Runnable或者Callable任务，或者通过cancel取消FutureTask的执行等

public class CallBackTest {

    static ExecutorService threadPool = Executors.newFixedThreadPool(1000);
    public static int count = 0;

    public static void main(String[] str) {
        FutureTask task = new FutureTask(new CallBackTest().new Task());
        for (int i = 1; i <= 1000; i++) {
            threadPool.submit(task);
        }
        threadPool.shutdown();
        try {
            if (!threadPool.awaitTermination(10000, TimeUnit.MILLISECONDS)) {
                // 超时的时候向线程池中所有的线程发出中断(interrupted)。
                threadPool.shutdownNow();
            }
        } catch (InterruptedException e) {
            threadPool.shutdownNow();
        }
        System.out.println(Thread.currentThread().getName() + ":" + count);

        addCallback(task, new FutureCallback() {

            @Override
            public void onSuccess(Object result) {
                System.out.println("future callback result:" + result);
            }

            @Override
            public void onFailure(Throwable t) {
                System.out.println(t);
            }

        });
    }

    private static <V> void addCallback(Future future, FutureCallback callback) {
        V value = null;
        if (future.isDone()) {
            try {
                value = (V)future.get();
            } catch (InterruptedException e) {
                callback.onFailure(e.getCause());
            } catch (ExecutionException e) {
                callback.onFailure(e.getCause());
            }
            callback.onSuccess(value);
        }
    }

    public interface FutureCallback<V> {
        void onSuccess(V result);

        void onFailure(Throwable t);
    }

    public class Task implements Callable<Integer> {

        @Override
        public Integer call() {
            synchronized (this) {
                count++;
                System.out.println(Thread.currentThread().getName() + ":" + count);
                try {
                    Thread.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return count;
        }

    }

 

run result:

pool-1-thread-1:1
main:1
future callback result:1

参考:http://www.cnblogs.com/Booker808-java/p/9502377.html

google guava Futures.addCallBack()方法实现