ExecutorService 线程池简介

1. Executors 创建线程池的方法

      newFixedThreadPool() 方法，该方法返回一个固定数量的线程池，该方法的线程数始终不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，则会被暂缓在一个任务队列中等待有空闲的线程去执行。适用场景：可用于Web服务瞬时削峰，但需注意长时间持续高峰情况造成的队列阻塞。

      newSingleThreadExecutor() 方法， 创建-一个线程的线程池，若空闲则执行，若没有空闲线程则暂缓在任务列队中。适用场景：快速处理大量耗时较短的任务，如Netty的NIO接受请求时，可使用CachedThreadPool。

      newCachedThreadPool() 方法， 返回一个可根据实际情况调整线程个数的线程池，不限制最大线程数量，若用空闲的线程则执行任务，若无任务则不创建线程。并且每一个空闲线程会在60秒后自动回收。

      newScheduledThreadPool() 方法，该方法返回一个SchededExecutorService对象，但该线程池可以指定线程的数量。
 

查看源码可知，上面的 四种方法其实都是实例化的

 ThreadPoolExecutor 对象

2.自定义线程池

既然我们都知道，上面的四种方法实际上就是 new ThreadPoolExecutor() 来的，所以当上面的四种方法满足不了我们的需求的时候，我们可以自定义线程池

ExecutorService pool = new ThreadPoolExecutor(
        1,  // 同时执行的线程数
        2,  // 最大线程数
        0L,  // 线程存活时间
         TimeUnit.SECONDS,  // 线程存活时间单位
         new ArrayBlockingQueue<>(3),  // 用什么队列
         new MyThreadFactory(), // 线程工厂可以自定义也可以不写
         new MyPolicy() // 拒绝策略，就是线程池满了存不进去的时候怎么办，
                        // 这个一般在使用有界队列的时候才会有这种问题
);

自定义线程池的关键在于用什么队列

A.有界队列，比如说  ArrayBlockingQueue

        在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolsize,则优先创建线程，若大于corePoolsize, 则会将任务加入队列，若队列已满，则在总线程数不大于maximumPoolsize的前提下，创建新的线程，若线程数大于maximumPoolSize,则执行拒绝策略。或其他自定义方式。

B.无界队列，比如说 LinkedBlockingQueue

       与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新任务到来，系统的线程数小于corePoolsize时，则新建线程执行任务。当达到corePoolsize后，就不会继续增加。若后续仍有新的任务加入，而有没有空闲的线程资源，则任务直接进入队列等待。若任务创建和处理的速度差异很大，无界队列会保持快速增长，直到耗尽系统内存。

C. 拒绝策略，jdk自带四种，也可以自定义，实现  RejectedExecutionHandler 接口，然后传入既可

• AbortPolicy:直接抛出异常，系统正常工作
• CallerRunsPolicy:只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。
• DiscardOldestPolicy:丢弃最老的一个请求，尝试再次提交当前任务。
• DiscardPolicy:丢弃无法处理的任务，不给予任何处理。

D.ThreadFactory 工厂，可以自定义，实现  ThreadFactory 接口，重写  newThread 方法即可

 

代码示例：

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Main2 {

    public static void main(String[] args) {

        ExecutorService pool = new ThreadPoolExecutor(
                1,  // 同时执行的线程数
                2,  // 最大线程数
                0L,  // 线程存活时间
                TimeUnit.SECONDS,  // 线程存活时间单位
                new ArrayBlockingQueue<>(3),  // 用什么队列
                new MyThreadFactory(), // 线程工厂可以自定义也可以不写
                new MyPolicy() // 拒绝策略，就是线程池满了存不进去的时候怎么办，
                // 这个一般在使用有界队列的时候才会有这种问题
        );

        Task t1 = new Task("1", "zhangzq");
        Task t2 = new Task("2", "licm");
        Task t3 = new Task("3", "zhangjy");
        Task t4 = new Task("4", "youy");
        Task t5 = new Task("5", "zhuyf");
        Task t6 = new Task("6", "lixw");

        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        pool.execute(t6);

        pool.shutdown();
    }

}
class Task implements Runnable{

    private String id;
    private String name;

    public Task(String id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Task{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public void run() {
        try {
            System.out.println( this.toString() );
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyThreadFactory implements ThreadFactory {

    private final AtomicInteger num = new AtomicInteger(1);

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r ,"zzq-Thread-"+ num.getAndIncrement() );
        System.out.println( t.getName() + " has been create... " );
        return t;
    }
}

class MyPolicy implements RejectedExecutionHandler{

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println( "该线程添加失败..."+r.toString() );
    }
}