import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

@Slf4j

public class FutureExample {

    static class MyCallable implements Callable<String> {

        @Override

        public String call() throws Exception {

            log.info("do something in callable");

            Thread.sleep();

            return "Done";

        }

    }

    public static void main(String[] args) throws Exception {

        ExecutorService executorService = Executors.newCachedThreadPool();

        Future<String> future = executorService.submit(new MyCallable());

        log.info("do something in main");

        //Thread.sleep(10000);

        log.info("这里不阻塞，可以继续异步执行");

        String result = future.get(); //get方法会发生阻塞，如果判断任务是否执行完成使用isDone()方法

        log.info("result：{}", result);

    }

}

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;

import java.util.concurrent.FutureTask;

@Slf4j

public class FutureTaskExample {

    public static void main(String[] args) throws Exception {

        FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {

            @Override

            public String call() throws Exception {

                log.info("do something in callable");

                Thread.sleep();

                return "Done";

            }

        });

        new Thread(futureTask).start();

        log.info("do something in main");

        Thread.sleep();

        String result = futureTask.get();

        log.info("result：{}", result);

    }

}

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.Future;

import java.util.concurrent.RecursiveTask;

@Slf4j

public class ForkJoinTaskExample extends RecursiveTask<Integer> {

    public static final int threshold = ;

    private int start;

    private int end;

    public ForkJoinTaskExample(int start, int end) {

        this.start = start;

        this.end = end;

    }

    @Override

    protected Integer compute() {

        int sum = ;

        //如果任务足够小就计算任务

        boolean canCompute = (end - start) <= threshold;

        if (canCompute) {

            for (int i = start; i <= end; i++) {

                sum += i;

            }

        } else {

            // 如果任务大于阈值，就分裂成两个子任务计算

            int middle = (start + end) / ;

            ForkJoinTaskExample leftTask = new ForkJoinTaskExample(start, middle);

            ForkJoinTaskExample rightTask = new ForkJoinTaskExample(middle + , end);

            // 执行子任务

            leftTask.fork();

            rightTask.fork();

            // 等待任务执行结束合并其结果

            int leftResult = leftTask.join();

            int rightResult = rightTask.join();

            // 合并子任务

            sum = leftResult + rightResult;

        }

        return sum;

    }

    public static void main(String[] args) {

        ForkJoinPool forkjoinPool = new ForkJoinPool();

        //生成一个计算任务，计算1+2+3+4

        ForkJoinTaskExample task = new ForkJoinTaskExample(, );

        //执行一个任务

        Future<Integer> result = forkjoinPool.submit(task);

        try {

            log.info("result:{}", result.get());

        } catch (Exception e) {

            log.error("exception", e);

        }

    }

}

在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。

认识BlockingQueue

BlockingQueue是一种数据结构，支持一个线程往里存资源，另一个线程从里取资源。这正是解决生产者消费者问题所需要的

      多线程环境中，通过队列可以很容易实现数据共享，比如经典的“生产者”和“消费者”模型中，通过队列可以很便利地实现两者之间的数据共享。假设我们有若干生产者线程，另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程，利用队列的方式来传递数据，就可以很方便地解决他们之间的数据共享问题。但如果生产者和消费者在某个时间段内，万一发生数据处理速度不匹配的情况呢？理想情况下，如果生产者产出数据的速度大于消费者消费的速度，并且当生产出来的数据累积到一定程度的时候，那么生产者必须暂停等待一下（阻塞生产者线程），以便等待消费者线程把累积的数据处理完毕，反之亦然。然而，在concurrent包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。好在此时，强大的concurrent包横空出世了，而他也给我们带来了强大的BlockingQueue。（在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒）
下面两幅图演示了BlockingQueue的两个常见阻塞场景：

  

如上图所示：当队列中没有数据的情况下，消费者端的所有线程都会被自动阻塞（挂起），直到有数据放入队列。

如上图所示：当队列中填满数据的情况下，生产者端的所有线程都会被自动阻塞（挂起），直到队列中有空的位置，线程被自动唤醒。