Java线程池Executor&ThreadPool

　　java自1.5版本之后，提供线程池，供开发人员快捷方便的创建自己的多线程任务。下面简单的线程池的方法及说明。

　　1、Executor 

　　　　线程池的顶级接口。定义了方法execute(Runnable)，该方法接收一个Runnable实例，用来执行一个任务，该任务即是一个实现Runnable接口的类。

　　　　此服务方法无返回值，原因是因为实现Runnable接口的类的run方法是无返回（void）的。

　　　　常用方法 ： void execute（execute）

　　　　作用 ： 启动并执行线程任务

　　2、ExecutorService

　　　　继承自Executor接口，提供了更多的方法调用，例如优雅关闭方法shutdown，有返回值的submit。

　　　　2.1、ExecutorService生命周期

　　　　　　运行 - Running 、关闭 - shuttingdown、终止 - terminated

　　　　　　Running ： 线程池正在执行中，活动状态。创建后即进入此状态

　　　　　　shuttingdown ： 优雅关闭，线程池正在关闭中。不再接收新的线程任务，已有的任务（正在处理的 + 队列中阻塞的），处理完毕后，关闭线程池。

　　　　　　　　　　　　　　调用shutdown()方法，即进入此状态

　　　　　　terminated ： 线程池已关闭。

　　　　2.2、submit方法

　　　　　　有返回值，Future类型。重载了方法，submit(Runnable)不需要提供返回值。submit(Callable)、submit(Runnable，T)可以提供线程执行后的结果返回值。

　　　　2.3、Future

　　　　　　线程执行完毕结果。获取线程执行结果是通过get()方法获取。get()无参，阻塞等待线程执行结束。

　　　　　　get(long timeout, TimeUnit unit)有参，阻塞等待固定时长，超时未获取，则抛出异常。

　　　　2.4、Callable

　　　　　　类似Runnable的一个线程接口。其中的对应run的方法是call方法。此接口提供了线程执行完毕返回值。

package com.cn.cfang.executor;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Test {
    public static void main(String[] args) throws Exception{
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        Data data = new Data();
//        Future<Data> future = executorService.submit(new Task(data), data); //runnable
        Future<Data> future = executorService.submit(new Task1(data)); //callable
        System.out.println(future.get().getName());
        executorService.shutdown();
    }
}

class Data {
    String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

class Task implements Runnable{
    Data data;
    public Task(Data data) {
        this.data = data;
    }
    @Override
    public void run() {
         data.setName("hello world");
    }
}

class Task1 implements Callable<Data>{
    Data data;
    public Task1(Data data) {
        this.data = data;
    }
    @Override
    public Data call() throws Exception {
        data.setName("hello world");
        return data;
    }
    
}

　　　3、Executors工具类

　　　　提供了很多的工厂方法用于创建线程池，返回的线程池都实现了ExecutorService接口。

线程池属于进程级的重量级资源，默认的生命周期同JVM一致，当开启线程池后，直到jvm关闭，是线程池的默认的生命周期。
如果手动调用shutdown方法，可优雅关闭线程池，在当前所有任务执行结束后，关闭线程池。

　　4、几种常用的线程池

　　　　4.1、FixedThreadPool

　　　　　容量固定的线程池。使用LinkedBlockingQueue作为任务队列，当任务数量大于线程池容量的时候，未执行的任务进入任务等待队列LinkedBlockingQueue中，

　　　　　当线程有空闲的时候，自动从队列中取出任务执行。

　　　　    使用场景： 大多数情况下，推荐使用的线程池。因为os系统和硬件是有线程上限限制的，不可能去无限的提供线程池操作。

　　　　4.2、CachedThreadPool

　　　　　　缓存线程池。容量 0-Integer.MAX_VALUE，自动根据任务数扩容：如果线程池中的线程数不满足任务执行需求，则创建新的线程并添加到池中。

　　　　　　生命周期默认60s，当线程空闲时长到60s的时候，自动终止销毁释放线程，移除线程池。

　　　　　　使用场景 ： 可用于测试最高负载量，用于对FixedThreadPool容量的参考。

　　　　　　注意，放入CachedThreadPool的线程不必担心其结束，超过TIMEOUT（默认60s）不活动，其会自动被终止。 

　　　　4.3、ScheduledThreadPool

　　　　　　定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(3);
        System.out.println(service);
        
        // 定时完成任务。 scheduleAtFixedRate(Runnable, start_limit, limit, timeunit)
        // runnable - 要执行的任务。
　　　　 // start_limit - 第一次执行任务的时间间隔
　　　　 // limit - 多次任务执行的时间间隔
        // timeunit - 时间单位
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }, 0, 300, TimeUnit.MILLISECONDS);
        
    }

　　　　4.4、SingleThreadExceutor 单一容量线程池。

　　　　4.5、自定义线程池

　　　　　　自定义线程池，可以使用ThreadPoolExecutor类来进行创建管理。线程池中，除了ForkJoinPool外，其他常用的线程池底层，都是使用ThreadPoolExecutor实现的。

　　　　　　参数说明：

　　　　　　　　corePoolSize：核心线程数，也是最少线程数。在创建线程池时，默认情况下，是不会创建线程池的，也即此时的线程池中线程数为0，直到有任务来临时，才会去创建线程。当然，手动调用prestartCoreThread()或者prestartAllCoreThreads()方法，可以初始化创建线程池中的线程。默认情况下，当有任务来临时，就会创建新的线程去处理执行，即使此时线程池中有空闲的线程。当线程数达到corePoolSize时，线程数不增加，此时任务会放入等待队列BlockingQueue中。

　　　　　　　　workQueue：阻塞队列，用来存储等待执行的任务资源。

　　　　　　  　 maximumPoolSize：最大线程数。当阻塞队列满了，开始扩充线程池中的线程数。直到达到此最大值的时候。

　　　　　　　　handler：当线程池中的线程数等于maximumPoolSize的时候，此时再来任务的话，交由此拒绝策略执行。

　　　　　　　　keepAliveTime：表示的线程在空闲多长时间后会被终止。默认是在线程数大于corePoolSize才生效，也可以手动设置allowCoreThreadTimeOut()方法让线程数在不大于　　corePoolSize也生效。

 public ThreadPoolExecutor(
    　　　　　　　　　int corePoolSize, //核心容量，创建线程池的时候，默认有多少的线程数。也是最少线程数
                   int maximumPoolSize, //最大线程数
                   long keepAliveTime,  //线程生命周期，0为永久。当线程空闲多长时间，自动回收。
                   TimeUnit unit,  //生命周期时间单位。
                  BlockingQueue<Runnable> workQueue,  //任务阻塞队列。
　　　　　　　　　　 RejectedExecutionHandler handler
　　　　　　) {
        　　　　this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), handler);
    　　　　　　}        

　　　　　　简单例子：

package com.cn.cfang.executor;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test2 {

    public static void main(String[] args){ 
        //创建等待队列 
        BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20); 
        //创建线程池，池中保存的线程数为3，允许的最大线程数为5
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,50,TimeUnit.MILLISECONDS,bqueue); 
        //创建七个任务 
        Runnable t1 = new MyThread(); 
        Runnable t2 = new MyThread(); 
        Runnable t3 = new MyThread(); 
        Runnable t4 = new MyThread(); 
        Runnable t5 = new MyThread(); 
        Runnable t6 = new MyThread(); 
        Runnable t7 = new MyThread(); 
        //每个任务会在一个线程上执行
        pool.execute(t1); 
        pool.execute(t2); 
        pool.execute(t3); 
        pool.execute(t4); 
        pool.execute(t5); 
        pool.execute(t6); 
        pool.execute(t7); 
        //关闭线程池 
        pool.shutdown(); 
    } 
}

class MyThread implements Runnable{ 
    @Override
    public void run(){ 
        System.out.println(Thread.currentThread().getName() + "正在执行。。。"); 
        try{ 
            Thread.sleep(100); 
        }catch(InterruptedException e){ 
            e.printStackTrace(); 
        } 
    } 
}

　5、forkjoin框架

　　　　拆分合并，将一个大的任务，拆分成若干子任务，并最终汇总子任务的执行结果，得到大任务的执行结果。并行执行，采用工作窃取机制，更加有效的利用cpu资源。

　　　　5.1、主要类

　　　　　　ForkJoinPool ： 用于执行Task。任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。

　　　　　　　　　　　　　　当一个工作线程的队列里暂时没有任务时，它会随机从其他未完成工作线程的队列的尾部获取一个任务。

　　　　　　ForkJoinTask：ForkJoin任务，提供在任务中执行fork()和join()操作的机制（二叉分逻辑），通常不直接继承ForkJoinTask类，

　　　　　　　　　　　　　而是继承抽象子类RecursiveTask（有返回结果） 或者 RecursiveAction （无返回结果）。

　　　　　　ForkJoinWorkerThread：ForkJoinPool 内部的worker thread，用来具体执行ForkJoinTask。内部有 ForkJoinPool.WorkQueue，来保存要执行的 ForkJoinTask。

　　　　　　ForkJoinPool.WorkQueue：保存要执行的ForkJoinTask。

　　　5.2、工作窃取机制

　　　　　　1、大任务分割成N个子任务，为避免线程竞争，于是分开几个队列去保存这些子任务，并为每个队列提供一个工作线程去处理其中的任务。工作线程与任务队列一一对应。

　　　　　　2、如果A线程执行完自己队列中的所有任务，如果此时其他队列中还有未执行的任务，则A线程会去窃取一个其他队列的任务来执行。但是，此时两个线程同时访问，

　　　　　　　　可能会产生竞争问题，所以，任务队列设计成了双向队列。A线程窃取的时候，从另一端开始执行，尽可能的去避免线程竞争问题。

　　　　　　3、工作窃取机制，充分的利用线程资源，并尽可能的去避免线程间的竞争问题。但是，只能是尽可能避免，并不能规避。例如，双向队列只有一个任务。

　　   5.3、简单使用

　　　　　　例：求和 0 - 10000000000L。

package com.cn.cfang.executor;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

/**
 * 步骤：
 *  1、建立任务类Task，继承RecursiveTask或者RecursiveAction。需要返回值则选用RecursiveTask，无需返回值选用RecursiveAction
 *  2、任务类Task，满足一定的阈值，则对子任务进行计算，不满足，则二叉分后，递归调用自身
 *  3、调用中，新建ForkJoinPool对象，新建任务类对象Task，将任务类对象Task放入ForkJoinPool中执行。
 *     如果需要返回值，则可以invoke或者Future-submit。
 * @author cfang
 * 2018年5月15日 上午10:51:03
 */
public class Test3 {
    
    public static void main(String[] args) throws Exception{
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinWorkTask task = new ForkJoinWorkTask(0l, 10000000l);
//        Long result = pool.invoke(task);
//        System.out.println(result);
        Future<Long> future = pool.submit(task);
        System.out.println(future.get());
    }
    
}

class ForkJoinWorkTask extends RecursiveTask<Long>{

    private static final long serialVersionUID = 1L;
    
    private Long start;    //起始
    private Long end;    //终止
    private static final Long THRESHOLD = 10000L; //子任务分割阈值
    
    public ForkJoinWorkTask(Long start, Long end){
        this.start = start;
        this.end = end;
    }
    
    @Override
    protected Long compute() {
        Long sum = 0l;
        if(end - start <= THRESHOLD){ //足够小的子任务，进行计算求和
            for(Long i = start; i < end; i++){
                sum += i;
            }
        }else{ //任务拆分不满足，继续拆分（二叉分逻辑）
            Long middle = (start + end) / 2;
            ForkJoinWorkTask rightTask = new ForkJoinWorkTask(start, middle);
            rightTask.fork();
            ForkJoinWorkTask leftTask = new ForkJoinWorkTask(middle + 1, end);
            leftTask.fork();
            sum = rightTask.join() + leftTask.join();
        }
        return sum;
    }
    
}