java线程池介绍

java线程池介绍

java高并发应用频繁创建和销毁线程的操作将是非常低效的，而且不被编程规范所允许的。如何降低java线程的创建成本，就必须用到线程池。

线程池主要解决以下问题：

1).提升性能： 线程池能独立负责线程的创建、维护、分配。在执行大量异步任务时，可以不需要自己创建线程，而是将任务交给线程池去调度。线程池能尽可能的使用空闲线程，去执行异步任务，最大限度的对已经创建的线程进行复用。使得性能有明显的提升。
2).线程管理： 每个java线程池都会保持一些线程的统计信息，例如完成的任务数量、空闲时间等，以便对线程进行有效的管理，使得能对所接受到的异步任务进行高效的调度。

JUC的线程池框架（JUC：java并发包的缩写）

java线程池的基本结构

ThreadPoolExecutor的构造方法源码：

    public ThreadPoolExecutor(int corePoolSize, //核心线程数（即空闲多长时间也不会被回收）
                              int maximumPoolSize, //线程数的上线
                              long keepAliveTime, //空闲线程的存活时间
                              TimeUnit unit,  //keepAliveTime参数的时间单位
                              BlockingQueue<Runnable> workQueue, //任务的排队队列
                              ThreadFactory threadFactory, //新线程的生产方式
                              RejectedExecutionHandler handler) //拒绝策略

线程池的任务调度流程：

execut方法的源码：

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        //工作线程数量小于核心线程数量，执行这个方法新建工作线程
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //如果核心线程数量大于核心线程数，就把任务添加到阻塞队列中
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //如果阻塞队列也满了，创建新线程
        //如果创建新线程失败了，说明线程数达到了最大线程数，则执行拒绝策略
        else if (!addWorker(command, false))
            reject(command);
    }

execut方法执行流程图：

runWorker方法源码（主要线程的主循环）

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        //拿到了一个任务
        Runnable task = w.firstTask;
        ...
        try {
       		 //第一次循环task不为空，直接进入循环体
       		 //第二次循环task为空，执行||后面的逻辑判断(task = getTask()) != null
       		 //getTask()是从 线程池队列中获取任务
       		 //此出while循环的作用就是：一直循环读取线程池队列中的任务并执行
            while (task != null || (task = getTask()) != null) {
               ...
                try {
                    beforeExecute(wt, task); //任务执行之前的钩子
                    try {
                    	//执行任务
                        task.run();
                        afterExecute(task, null); //任务执行之后的钩子
                    } catch (Throwable ex) {
                        afterExecute(task, ex);
                        throw ex;
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

线程池是一把双刃剑:

优点：
1).降低资源消耗：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，通过重复利用已经创建的线程，可以降低线程创建和销毁造成的消耗。
2).提高响应速度：当任务到达时，可以不用等待线程创建就能立即执行任务。
3).提高线程的可管理性：线程池提供了一种限制、管理资源的策略，维护一些基本的线程统计信息，如已完成任务的数量等。通过线程池可以对线程资源进行统一的分配、监控和调优。
缺点：
虽然线程池的好处很多，但是其线程数量配置不合理，不仅可能达不到预期的效果，反而会降低应用的性能。

线程的数量和异步任务类型是分不开的，根据所执行异步任务的类型合理的配置线程数量。
线程池的异步任务分为三类：
1.IO密集型任务

此类任务主要执行IO操作。由于IO的执行时间较长，导致CPU的利用率不高，这类CPU常处于空闲状态。例如 Netty的IO读写操作。
一般核心线程数是cpu核数的两倍

2.CPU密集型任务

此类任务主要是执行计算任务。由于相应时间很快CPU一直在运行，这种任务CPU的利用率很高。
一般情况下线程数就是cpu的核数

3.混合型任务

此类任务既要执行逻辑计算，也要执行IO操作（如RPC调用、数据库访问）。相对来说由于执行IO操作的耗时较长（一次网络往返往往在数百毫秒级别），这类任务CPU利用率也不是太高。例如 Web服务器的HTTP请求处理操作。
理论最佳线程数=（（线程等待时间+线程cpu时间）/ 线程cpu时间）* CPU核数
化简后为：理论最佳线程数=（线程等待时间与线程CPU时间之比+1）*CPU核数

一般情况下，需要根据不同的异步任务类型创建不同的线程池，并进行针对性的配置参数。