Java 线程池 Executors

参考链接：http://www.wuzesheng.com/?p=2485 

pom.xml

 <dependencies>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>20.0</version>
        </dependency>
    </dependencies>

import com.google.common.util.concurrent.*;
import java.util.concurrent.*;

class MyCallable implements Callable<String> {

   private String name;

   public MyCallable(String name) {
       this.name = name;
   }

   @Override
   public String call() throws Exception{
       Thread.sleep(5000);
       System.out.println("execute thread:" + Thread.currentThread().getId());
       return name;
   }
}

public class Main {

    public void testFuture() throws ExecutionException, InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(1); //特定个数的线程池
        //ExecutorService executorService = Executors.newSingleThreadExecutor(); //单个线程池
        //ExecutorService executorService = Executors.newCachedThreadPool(); //当有任务时，线程池数量可以不断变大，INT_MAX,当没有任务时，会回收线程
        //ExecutorService executorService = Executors.newScheduledThreadPool(); //定时执行任务。

        Future<String> future = executorService.submit(new MyCallable("test"));
        String result = future.get(); // 由于这个是阻塞的，因此如果有多个任务时可能会因为这个导致阻塞，以此产生了 ListeningFuture
        System.out.println(result);
    }

    public void testListeningFuture() {

        // 用 Executors.newFixdeThreadPool(1) 里面的线程来执行 MyCallable.
        ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(1));
        final ListenableFuture<String> listenableFuture = listeningExecutorService.submit(new MyCallable("listening thread"));

        //这个方法也是可以的，只是和下面的比，比较麻烦
//        listenableFuture.addListener(new Runnable() {
//            @Override
//            public void run() {
//                try {
//                    System.out.println(listenableFuture.get());
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                } catch (ExecutionException e) {
//                    e.printStackTrace();
//                }
//            }
//        }, Executors.newFixedThreadPool(1));

        Futures.addCallback(listenableFuture, new FutureCallback<String>() {
            @Override
            public void onSuccess(String s) {
                System.out.println(Thread.currentThread().getId() + " " + s + " succeed");
            }

            @Override
            public void onFailure(Throwable throwable) {
                System.out.println(Thread.currentThread().getId() + " failed");
            }
        }, Executors.newFixedThreadPool(1));// 这个是哪一个线程来执行FutureCallback 的内容
        System.out.println("exit..");
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main: " + Thread.currentThread().getId());
        Main m = new Main();
        m.testFuture();
        m.testListeningFuture();
    }
}