JAVA六大线程池详解

1）Executor执行器

详解

线程池的最顶层接口，内部就一个execute方法yong书写线程的具体执行方式

public class testExecutor implements Executor {public static void main(String[] args) {new testExecutor().execute(()-> System.out.println("hello "));}@Overridepublic void execute(Runnable command) {//        command.run();new Thread(command).start();}
}

2）Executors

这是一个工厂类，里面包含了创建线程池的方法

3）ExecutorService

一个继承了Executor的接口，基本上所有的线程池都是继承了这个接口或者它的实现类

4）Callable

主要是跟Runnable的区别：Callable有返回值并且可以抛出异常

5）启动一个固定个数的线程池

ExecutorService service= Executors.newFixedThreadPool(5);

public class To_5_ThreadPool {public static void main(String[] args) throws InterruptedException {//启动一个固定的线程池，所以的线程池都实现了这个接口 ExecutorServiceExecutorService service= Executors.newFixedThreadPool(5);for(int i=0;i<6;i++){service.execute(()->{try{TimeUnit.MICROSECONDS.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName());});}System.out.println(service);service.shutdown();//等待所有的任务都执行完再关闭System.out.println(service.isTerminated());//是不是所有的线程都执行完了System.out.println(service.isShutdown());//是不是正在关闭System.out.println(service);TimeUnit.SECONDS.sleep(5);System.out.println(service.isTerminated());System.out.println(service.isShutdown());System.out.println(service);}
}

作用：该线程池拥有一个共享无边界队列，在任何时间点，最多有指定的个数线程在活动，当所有线程都在活动时，有任务提交过来，这个任务会一直在队列中等待，直到线程执行完这个任务。队列实例为

6)Future

表示一个可能还没有完成的异步任务的结果，有RunnableFuture和SchedualFuture继承这个接口，以及CompleteFuture和ForkJoinTask。

public static void main(String[] args) throws ExecutionException, InterruptedException {//包装一个Callable方法FutureTask<Integer>task=new FutureTask<>(()->{TimeUnit.MICROSECONDS.sleep(500);return 1000;});new Thread(task).start();System.out.println(task.get());//阻塞获取task方法ExecutorService service= Executors.newFixedThreadPool(5);Future<Integer>f=service.submit(()->{TimeUnit.MICROSECONDS.sleep(500);return 1;});System.out.println(f.isDone());System.out.println(f.get());//什么时候执行完什么时候拿到结果System.out.println(f.isDone());}

RunnableFuture

这个接口同时继承Future接口和Runnable接口，在成功执行run（）方法后，可以通过Future访问执行结果。这个接口都实现类是FutureTask,一个可取消的异步计算，这个类提供了Future的基本实现，后面我们的demo也是用这个类实现，它实现了启动和取消一个计算，查询这个计算是否已完成，恢复计算结果。计算的结果只能在计算已经完成的情况下恢复。如果计算没有完成，get方法会阻塞，一旦计算完成，这个计算将不能被重启和取消，除非调用runAndReset方法。
FutureTask能用来包装一个Callable或Runnable对象，因为它实现了Runnable接口，而且它能被传递到Executor进行执行。为了提供单例类，这个类在创建自定义的工作类时提供了protected构造函数。

SchedualFuture

这个接口表示一个延时的行为可以被取消。通常一个安排好的future是定时任务SchedualedExecutorService的结果

CompleteFuture

一个Future类是显示的完成，而且能被用作一个完成等级，通过它的完成触发支持的依赖函数和行为。当两个或多个线程要执行完成或取消操作时，只有一个能够成功。

ForkJoinTask

基于任务的抽象类，可以通过ForkJoinPool来执行。一个ForkJoinTask是类似于线程实体，但是相对于线程实体是轻量级的。大量的任务和子任务会被ForkJoinPool池中的真实线程挂起来，以某些使用限制为代价。

主要方法：

get（）方法可以当任务结束后返回一个结果，如果调用时，工作还没有结束，则会阻塞线程，直到任务执行完毕

get（long timeout,TimeUnit unit）做多等待timeout的时间就会返回结果

cancel（boolean mayInterruptIfRunning）方法可以用来停止一个任务，如果任务可以停止（通过mayInterruptIfRunning来进行判断），则可以返回true,如果任务已经完成或者已经停止，或者这个任务无法停止，则会返回false.

isDone（）方法判断当前方法是否完成

isCancel（）方法判断当前方法是否取消

public static void main(String[] args) throws ExecutionException, InterruptedException {//包装一个Callable方法FutureTask<Integer>task=new FutureTask<>(()->{TimeUnit.MICROSECONDS.sleep(500);return 1000;});new Thread(task).start();System.out.println(task.get());//阻塞获取task方法ExecutorService service= Executors.newFixedThreadPool(5);Future<Integer>f=service.submit(()->{TimeUnit.MICROSECONDS.sleep(500);return 1;});System.out.println(f.isDone());System.out.println(f.get());//什么时候执行完什么时候拿到结果System.out.println(f.isDone());}

7) CachedThreadPool

public static void main(String[] args) throws InterruptedException {
//每来一个线程如果有空闲的话直接用空闲的，如果没有的话new一个新的，空闲线程超过一分钟的话就
// 自动销毁
ExecutorService service= Executors.newCachedThreadPool();
System.out.println(service);

    for(int i=0;i<2;i++){service.execute(()->{try{TimeUnit.MICROSECONDS.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName());});}System.out.println(service);TimeUnit.SECONDS.sleep(10);System.out.println(service);}

}

public static void main(String[] args) throws InterruptedException {//每来一个线程如果有空闲的话直接用空闲的，如果没有的话new一个新的，空闲线程超过一分钟的话就// 自动销毁ExecutorService service= Executors.newCachedThreadPool();System.out.println(service);for(int i=0;i<2;i++){service.execute(()->{try{TimeUnit.MICROSECONDS.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName());});}System.out.println(service);TimeUnit.SECONDS.sleep(10);System.out.println(service);}
}

作用：

该线程池创建的数量几乎没有限制，如果往该线程池中提交任务，线程池中没有空闲现程，则新建线程，如果有则直接重用，线程在规定时间内如果一直空闲，则自动终止。

8） SingleThreadExecutor

  public static void main(String[] args) {//永远都只有一个线程的线程池ExecutorService service= Executors.newSingleThreadExecutor();for(int i=0;i<6;i++){final int j=i;service.execute(()->{System.out.println(Thread.currentThread().getName());});}}

作用：

它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

9） ScheduledThreadPool

ScheduledExecutorService service= Executors.newScheduledThreadPool(4);

 public static void main(String[] args) {//定时器线程池ScheduledExecutorService service= Executors.newScheduledThreadPool(4);//以固定的频率来执行某个任务service.scheduleAtFixedRate(()->{try{TimeUnit.MICROSECONDS.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName());},0,500,TimeUnit.MICROSECONDS);}}

作用：

继承ThreadPoolExecutor且实现了ScheduledExecutorService接口，它就相当于提供了“延迟”和“周期执行”功能的ThreadPoolExecutor。任务队列为DelayQueue

10) WorkStealingPool

public static void main(String[] args) throws IOException {//使用forkjoinpool实现的ExecutorService service= Executors.newWorkStealingPool();service.execute(new R(1000));service.execute(new R(2000));service.execute(new R(2000));service.execute(new R(2000));service.execute(new R(2000));
//产生的是后台线程，主线程不阻塞看不到输出System.in.read();}static class R implements Runnable{int time;R(int t){time=t;}@Overridepublic void run() {try{TimeUnit.MICROSECONDS.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName());}}

特点

每个线程都有要处理的队列中的任务，如果其中的线程完成自己队列中的任务，那么它可以去其他线程中获取其他线程的任务去执行，其内部会创建ForkJoinPool，利用Work-Stealing算法，并行的处理任务，不保证处理顺序。

11) ForkJoinPool

public class T11_FORKjOINpool {static int[] nums=new int[1000000];
static final  int MAX_NUM=50000;
static Random r=new Random();
static {for(int i=0;i<nums.length;i++){nums[i]=r.nextInt();}System.out.println(Arrays.stream(nums).sum());
}
static class AddTask extends RecursiveAction{//递归任务，无返回值RecursiveTaskint start,end;AddTask(int s,int e){start=s;end=e;}@Overrideprotected void compute() {if(end-start<=MAX_NUM){long sum=0L;for(int i=start;i<end;i++) sum+=nums[i];System.out.println("from: "+start+" to:"+end+" = "+sum);}else {int middle=start+(end-start)/2;AddTask subTask1=new AddTask(start,middle);AddTask subTask2=new AddTask(start,middle);subTask1.fork();subTask2.fork();}}public static void main(String[] args) throws IOException {ForkJoinPool fjp=new ForkJoinPool();AddTask task=new AddTask(0,nums.length);System.in.read();}
}
}

说明链接：
https://segmentfault.com/a/1190000008140126

12）ThreadPoolExecutor

https://www.jianshu.com/p/c41e942bcd64