guava中线程同步的代码和一个学习网站

/**
 * 
 */
package com.qunar.qfc.guanyingpiao.basic.concurrent;

import com.google.common.base.Function;
import com.google.common.util.concurrent.AsyncFunction;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 
 *
 * @author Guanying Piao
 *
 * 2018-06-30
 */
public class FuturesDemo {

    private static Logger logger = LoggerFactory.getLogger(FuturesDemo.class);
    
    public static void main(String[] args) {
        AtomicInteger threadIndex = new AtomicInteger(0);//设置一个原子的自增变量
        ExecutorService executorService = Executors.newFixedThreadPool(5, r -> new Thread(r, "thread-" + threadIndex.getAndIncrement()));//创建线程池
        ListeningExecutorService listeningExecutorService = MoreExecutors.listeningDecorator(executorService);//管理着线程池
        ExecutorService finishExecutorService = Executors.newSingleThreadExecutor(r -> new Thread(r, "finisher"));//这是一个单独的线程
        int jobCount = 5;
        List<ListenableFuture<String>> listenableFutures = new ArrayList<>(jobCount); 
        for (int i = 0; i < jobCount; i++) {
            //这里往线程池中循环的投递任务
            ListenableFuture<Long> firstFuture = listeningExecutorService.submit(() -> {
                try {
                    Thread.sleep(ThreadLocalRandom.current().nextLong(1000L));//并发情况下这个随机数生成器效率更好
                } catch (InterruptedException e) {
                    logger.warn("Interrupted while waiting for permit");
                }
                return 123L;
            });

           /* ListenableFuture<Long> firstFuture = listeningExecutorService.submit(new Callable<Long>() {

                public Long call() throws Exception {
                    try {
                        Thread.sleep(ThreadLocalRandom.current().nextLong(1000L));//并发情况下这个随机数生成器效率更好
                    } catch (InterruptedException e) {
                        logger.warn("Interrupted while waiting for permit");
                    }
                    return System.currentTimeMillis();
                }
            });*/
            try {
                Thread.sleep(1000);
            }catch (InterruptedException e){

            }
            //对前面的firstFuture任务进行监听，如果firstFutrue任务结束了，在listeningExecutorService线程池中，调用中间的这个回调函数
            //由于是transformAsync，所以后面new的是AsyncFunction，同时返回值不能是Long，只能是ListenableFuture<Long>，所以我们下面要return listeningExecutorService.submit
            //相当于继续往线程池中投递任务
            ListenableFuture<Long> secondFuture = Futures.transformAsync(firstFuture, new AsyncFunction<Long, Long>() {
                @Override
                public ListenableFuture<Long> apply(Long input) throws Exception {
                    return listeningExecutorService.submit(() -> {
                        try {
                            Thread.sleep(ThreadLocalRandom.current().nextLong(1000L));
                        } catch (InterruptedException e) {
                            logger.warn("Interrupted while waiting for permit");
                        }
                        return input;
                    });
                }                
            }, listeningExecutorService);
            //下面是对secondFuture进行监听，如果结束了，在finishExecutorService这个线程中执行回调函数
            //由于是同步的，所以返回值就可以是正常的值了
            ListenableFuture<String> thirdFuture = Futures.transform(secondFuture, new Function<Long, String>() {
                @Override
                public String apply(Long input) {
                    return String.valueOf(input);
                }
            }, finishExecutorService);
            listenableFutures.add(thirdFuture);//将返回的ListenableFutrue装在一个链表中
        }
        //将这个链表中的每一个ListenableFuture判断，用null代替失败，然后将其装入ListenableFuture<List<String>>中
        //里层的链表应该就是代表之前成功的返回值
        ListenableFuture<List<String>> allFuture = Futures.successfulAsList(listenableFutures);
        //如果allFuture这里面里层的链表都执行完了，在finishExecutorService线程调用回调函数
        Futures.addCallback(allFuture, new FutureCallback<List<String>>() {
            @Override
            public void onSuccess(List<String> result) {
                logger.info("job done times:{}", result);
            }
            @Override
            public void onFailure(Throwable t) {
                logger.warn("Got exception:{}", t.getMessage());
            }            
        }, finishExecutorService);
        
        try {
            allFuture.get();
        } catch (InterruptedException | ExecutionException e) {
            logger.warn("Failed to wait for jobs to end");
        }
        executorService.shutdown();
        finishExecutorService.shutdown();
    }

}

CompletableFuture：https://www.jb51.net/article/51163.htm