java并发编程学习2--Future

【Future的概念

interface Future<V> ，表示异步计算的结果，Future有个get方法而获取结果只有在计算完成时获取，不然会一直阻塞直到任务转入完成状态，而后会返回结果或者抛出异常。相对于继承Thread来建立线程方式，使用Runnable可让你的实现类同时实现多个接口，而相对于Callable及Future，Runnable方法并不返回任务执行结果且不能抛出异常。

【interface Future<V> 具备以下方法

public interface Future<V> {
    //取消计算，若是还没有开始，直接取消再也不运算，若是正在进行：mayInterruptIfRunning等于true就会被中断。注意一点：只要调用了cancle()，不管任务是否可以执行，再调用get()都会出现cancledException,这是因为Future.state的状态被置为CANCELLED = 4，所致的;
    boolean cancel(boolean mayInterruptIfRunning)
    //判断计算是否取消。
    boolean isCancelled();
    //判断计算是否完成，若是计算完成返回true，不然返回false
    boolean isDone();
    //得到异步计算的结果，若是在调用get()的时候结果尚未计算出来，调用线程将被阻塞。
    V get() throws InterruptedException, ExecutionException;
    //得到异步计算的结果，若是在调用get()的时候结果尚未计算出来，调用线程将被阻塞。若是调用超时将会抛出TimeoutException。
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

补充：

- FutureTask：包装器，能够将Callable转换成为Future与Runnable,它同时实现了两者的接口。
   - Callable:能够为异步方法返回计算结果。

【下面咱们实现一种基于Future的场景

public class Exercise {

       private SimpleApplicationService simpleApplicationService = new SimpleApplicationService();

       @Test
       public void futureTest() throws InterruptedException, ExecutionException {
           long st = System.currentTimeMillis();
           //这里本是一callable接口实现，我用lambda方便一点
           FutureTask result = new FutureTask<String>(() -> simpleApplicationService.query());
           //记住咱们的任务都与须要开启一个新的线程
           Thread t = new Thread(result);
           t.start();
           long end = System.currentTimeMillis();
           System.out.println("耗时：" + (end - st) + " 结果：" + result.get());
       }
   }

   public class SimpleApplicationService {
       public String query() throws InterruptedException {
           System.out.println("开始查询");
           Thread.sleep(2000);
           return "query result";
       }
   }

【反思一些问题:

1. 每一个异步方法都须要新开启一个线程这样很消耗资源。
2. 每次都要new一个thread挺麻烦的。

【解决方案:使用线程池

1. 构建一个新的线程是有代价的，由于设计到与操做系统的交互。若是程序中建立了大量的而且生命周期很短的线程，咱们应该使用线程池。
   一个线程池包含不少准备运行的空闲线程，每当run()执行完毕后，线程不会死亡而是回到线程池准备为下一个请求提供服务。
2. 另外一个使用线程池的理由是减小并发线程数。建立大量线程会大大下降性能甚至拖垮虚拟机。

【Executor介绍

Executors类有许多静态方法可建立线程池。例如：

• Executors.newCachedThreadPool():对于一个任务，有空闲线程可用则会当即执行，不然建立一个新的线程。空闲线程存活60s。
• Executors.newFixedThreadPool(n):构建具备固定大小的线程池，若任务多余空闲线程数，则将多余任务放置等待队列中。
• Executors.newSingleThreadExecutor()：只有一个空闲线程的线程池，任务执行一个接一个;
• 以上三个方法返回ExecutorService接口的ThreadPoolExecutor对象。

核心(简介)：

ThreadPoolExecutor

public class ThreadPoolExecutor extends AbstractExecutorService {

        public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                BlockingQueue<Runnable> workQueue);

        public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);

        public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);

        //事实上，前面三个构造器都是调用的第四个构造器进行的初始化工做。
        public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);

    }

参数含义：

• corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有很是大的关系。在建立了线程池后，默认状况下，线程池中并无任何线程，而是等待有任务到来才建立线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法。从这2个方法的名字就能够看出，是预建立线程的意思，即在没有任务到来以前就建立corePoolSize个线程或者一个线程。默认状况下，在建立了线程池后，线程池中的线程数为0。当有任务来以后，就会建立一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
• maximumPoolSize：线程池最大线程数，这个参数也是一个很是重要的参数，它表示在线程池中最多能建立多少个线程；
• keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认状况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起做用。直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，若是一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。可是若是调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起做用，直到线程池中的线程数为0；
• unit：参数keepAliveTime的时间单位

• workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，通常来讲，这里的阻塞队列有如下几种选择:

  - ArrayBlockingQueue
     - LinkedBlockingQueue
     - SynchronousQueue;

• threadFactory：线程工厂，主要用来建立线程；

• handler：表示当拒绝处理任务时的策略，有如下四种取值：

  - ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
            - ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，可是不抛出异常。
            - ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，而后从新尝试执行任务（重复此过程）
            - ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

使用链接池应该作的事：

1. 调用Executors的静态方法建立线程池。
 2. 调用submit(),提交一个Callable对象或者Runnable对象。
 3. 保存好得到的Future<>对象，其中是计算结果(若是提交的是Callable)。
 4. 没有任何任务再提交的时候使用shutDown()。

---

public class TaskExercise {
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //future + callable
            ExecutorService executor = Executors.newCachedThreadPool();
            CallTask callTask = new CallTask();
            Future<String> taskReturn = executor.submit(callTask);
            System.out.println(taskReturn.get());
            //futureTask
            FutureTask<String> futureTask = new FutureTask<String>(callTask);
            executor.submit(futureTask);
            System.out.println(futureTask.get());
            //runable
            Runnable runTask = new RunTask();
            String result = "xz";
            Future<?> runTaskReturn = executor.submit(runTask,result);
            System.out.println(runTaskReturn.get());

            executor.shutdown();
        }
    }
    class CallTask implements Callable<String>{
        @Override
        public String call() throws Exception {
            return "task return";
        }
    }
    class RunTask implements Runnable{
        @Override
        public void run() {
            System.out.println("run");
        }
    }

【控制任务组

有时使用执行器更有意义的场景是控制一组相关任务。

1. shutdownNow():取消全部任务
2. invokeAny():提交全部对象到一个Callable对象集合，并返回某个已完成的任务结果。例如：若是你愿意接受任何一种解决方案的话。
3. 还有其余一些方法等咱们真正用到时再学习好了~

【补充

spring中实现异步调用：spring为任务调度与异步方法执行提供了注解支持。经过在方法上设置@Async注解，可以使得方法被异步调用。也就是说调用者会在调用时当即返回，而被调用方法的实际执行是交给Spring的TaskExecutor来完成。若是是有返回值的话记得：接口返回Future<>,实现返回AsyncResult<>。