java executor 线程池_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 classTest {public static voidmain(String[] args) throws Exception{

ExecutorService executorService= Executors.newFixedThreadPool(1);

Data data= newData();//Future future = executorService.submit(new Task(data), data);//runnable

Future future = executorService.submit(new Task1(data)); //callable

System.out.println(future.get().getName());

executorService.shutdown();

}

}classData {

String name;publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}

}classTask implements Runnable{

Data data;publicTask(Data data) {this.data =data;

}

@Overridepublic voidrun() {

data.setName("hello world");

}

}class Task1 implements Callable{

Data data;publicTask1(Data data) {this.data =data;

}

@OverridepublicData call() throws Exception {

data.setName("hello world");returndata;

}

}

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 voidmain(String[] args) {

ScheduledExecutorService service= Executors.newScheduledThreadPool(3);

System.out.println(service);//定时完成任务。 scheduleAtFixedRate(Runnable, start_limit, limit, timeunit)//runnable - 要执行的任务。

// start_limit - 第一次执行任务的时间间隔　　　　 // limit - 多次任务执行的时间间隔

// timeunit - 时间单位

service.scheduleAtFixedRate(newRunnable() {

@Overridepublic voidrun() {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也生效。

publicThreadPoolExecutor(intcorePoolSize, //核心容量，创建线程池的时候，默认有多少的线程数。也是最少线程数intmaximumPoolSize, //最大线程数longkeepAliveTime, //线程生命周期，0为永久。当线程空闲多长时间，自动回收。

TimeUnit unit, //生命周期时间单位。

BlockingQueueworkQueue, //任务阻塞队列。

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 classTest2 {public static voidmain(String[] args){//创建等待队列

BlockingQueue bqueue = new ArrayBlockingQueue(20);//创建线程池，池中保存的线程数为3，允许的最大线程数为5

ThreadPoolExecutor pool = new ThreadPoolExecutor(3,5,50,TimeUnit.MILLISECONDS,bqueue);//创建七个任务

Runnable t1 = newMyThread();

Runnable t2= newMyThread();

Runnable t3= newMyThread();

Runnable t4= newMyThread();

Runnable t5= newMyThread();

Runnable t6= newMyThread();

Runnable t7= newMyThread();//每个任务会在一个线程上执行

pool.execute(t1);

pool.execute(t2);

pool.execute(t3);

pool.execute(t4);

pool.execute(t5);

pool.execute(t6);

pool.execute(t7);//关闭线程池

pool.shutdown();

}

}classMyThread implements Runnable{

@Overridepublic voidrun(){

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 classTest3 {public static voidmain(String[] args) throws Exception{

ForkJoinPool pool= newForkJoinPool();

ForkJoinWorkTask task= new ForkJoinWorkTask(0l, 10000000l);//Long result = pool.invoke(task);//System.out.println(result);

Future future =pool.submit(task);

System.out.println(future.get());

}

}class ForkJoinWorkTask extends RecursiveTask{private static final long serialVersionUID = 1L;private Long start; //起始

private Long end; //终止

private static final Long THRESHOLD = 10000L; //子任务分割阈值

publicForkJoinWorkTask(Long start, Long end){this.start =start;this.end =end;

}

@OverrideprotectedLong 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= newForkJoinWorkTask(start, middle);

rightTask.fork();

ForkJoinWorkTask leftTask= new ForkJoinWorkTask(middle + 1, end);

leftTask.fork();

sum= rightTask.join() +leftTask.join();

}returnsum;

}

}