java~线程池的总结~续

上一讲主要谈了java里的线程池的使用，而主要使用Executors的方式去创建，比如 Executors.newCachedThreadPool(), Executors.newFixedThreadPool(5)等等，而这些方式在阿里手册里是不被推荐的，而是推荐使用ThreadPoolExecutor的方式，我想应该也是避免资源耗尽的风险吧！

线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

ThreadPoolExecutor实现的线程池

阿里巴巴的JAVA开发手册推荐用ThreadPoolExecutor创建线程池。来看看ThreadPoolExecutor创建线程池的api:

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

参数解释

corePoolSize ： 线程池核心池的大小。
maximumPoolSize ： 线程池的最大线程数。
keepAliveTime ： 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
unit ： keepAliveTime 的时间单位。
workQueue ： 用来储存等待执行任务的队列。
threadFactory ： 线程工厂。
handler  拒绝策略。

原理

有请求时，创建线程执行任务，当线程数量等于corePoolSize时，请求加入阻塞队列里，当队列满了时，接着创建线程，线程数等于maximumPoolSize。 当任务处理不过来的时候，线程池开始执行拒绝策略。

阻塞队列

ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。
DelayQueue： 一个使用优先级队列实现的无界阻塞队列。
SynchronousQueue： 一个不存储元素的阻塞队列。
LinkedTransferQueue： 一个由链表结构组成的无界阻塞队列。
LinkedBlockingDeque： 一个由链表结构组成的双向阻塞队列。

拒绝策略

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

Executors的弊端

1. newFixedThreadPool 和 newSingleThreadExecutor:主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至 OOM。
2. newCachedThreadPool 和 newScheduledThreadPool:主要问题是线程数最大数是 Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至 OOM。

合理配置线程池大小

根据任务所需要的cpu和io资源的量可以分为:

1. CPU密集型任务: 主要是执行计算任务，响应时间很快，cpu一直在运行，这种任务cpu的利用率很高。
2. IO密集型任务：主要是进行IO操作，执行IO操作的时间较长，这是cpu出于空闲状态，导致cpu的利用率不高。

为了合理最大限度的使用系统资源同时也要保证的程序的高性能，可以给CPU密集型任务和IO密集型任务配置一些线程数。

1. CPU密集型：线程个数为CPU核数。这几个线程可以并行执行，不存在线程切换到开销，提高了cpu的利用率的同时也减少了切换线程导致的性能损耗
2. IO密集型：线程个数为CPU核数的两倍。到其中的线程在IO操作的时候，其他线程可以继续用cpu，提高了cpu的利用率。

什么时候会走拒绝策略

如果你有10个线程，而线程池的配置是maximumPoolSize=4,ArrayBlockingQueue.length=3,corePoolSize=3，那么当你的线程产生的数量大于maximumPoolSize+ArrayBlockingQueue.length，即大于4+3时，就会走拒绝策略。

@SneakyThrows
@Test
public void threadPoolExecutor() {
    RejectedExecutionHandler handler = new MyIgnorePolicy();
    ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 4, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3),
            handler);
    for (int i = 1; i <= 5; i++) {
        MyTask task = new MyTask(String.valueOf(i));
        executor.execute(task);
    }

    System.in.read(); //阻塞主线程
}
public static class MyIgnorePolicy implements RejectedExecutionHandler {

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        doLog(r, e);
    }

    private void doLog(Runnable r, ThreadPoolExecutor e) {
        // 可做日志记录等
        System.err.println(r.toString() + " rejected");
    }
}

static class MyTask implements Runnable {
    private String name;

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

    @Override
    public void run() {
        try {
            System.out.println(this.toString() + " is running!");
            Thread.sleep(3000); //让任务执行慢点
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "MyTask [name=" + name + "]";
    }
}

结果，将有7个被执行，3个被拒绝

总结：线程池中核心数只影响任务处理的速度，而是否会走拒绝策略是由最大线程数和队列长度决定的。