Java线程池

在讲线程前，先对线程知识做进一步补充。

线程与进程的区别

从包含关系上看：

线程是对进程的一种细化，一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的(私有)程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

从资源管理方式上看：

进程和线程的主要差别在于它们是不同的操作系统资源管理方式。 进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉。所以多进程比多线程更健壮。

总结：线程是对进程的进一步的划分，线程共用方法区和堆内存，有自己独立的栈空间，而进程有自己独立的地址空间，线程没有，所以当一个线程被阻塞时会影响到整个进程，而进程崩溃并不会影响到其他进程。

线程生命周期：

java中线程的生命周期为：初始、运行、等待、阻塞、超时等待、销毁。而操作系统中将则是分为：初始、就绪、运行、等待、销毁。

1、线程池

程序的运行，其本质上，是对系统资源(CPU、内存、磁盘等等)的使用。高效的使用这些资源是编程优化演进的一个方向。传统的单个线程的创建使用太耗费资源，存在效率低管理不遍等缺陷。而池化技术的出现，很好的解决了单个线程创建的缺点。
池化技术：
池化技术简单点来说，就是提前保存大量的资源，以备不时之需。在机器资源有限的情况下，使用池化技术可以大大的提高资源的利用率，提升性能等。有了池化技术，线程池也就理所当然的派上用场。
线程池的优势：
线程池的主要特点有：① 线程复用性高 ② 能控制最大并发数 ③便于管理线程
优势：

• 降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。
• 提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配，调优和监控

2、线程池的三种创建方式

 	//单个线程
 	ExecutorService threadExecutor1 = Executors.newSingleThreadExecutor();
    // 创建一个固定的线程池大小
    ExecutorService threadExecutor2 = Executors.newFixedThreadPool(5);
    // 可伸缩的，根据需要自行创建线程数，有上限
    ExecutorService threadExecutor3 = Executors.newCachedThreadPool();

第一种方式只创建了一个线程：

public class MyThreadPoolDemo {
    public static void main(String[] args) {
		// 有且只有一个固定的线程
        ExecutorService threadPool =
                Executors.newSingleThreadExecutor();
        try {
		// 模拟有10个顾客过来银行办理业务，池子中只有1个工作人员受理业务
            for (int i = 1; i <= 10; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" 办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown(); // 用完记得关闭
        }
    }
}

第二种方式可以固定线程池的容量大小，合理分配内存大小可以使系统资源利用率最大化

public class MyThreadPoolDemo {
    public static void main(String[] args) {
		// 池子大小 5
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        try {
		// 模拟有10个顾客过来银行办理业务，池子中只有5个工作人员受理业务
            for (int i = 1; i <= 10; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" 办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown(); // 用完记得关闭
        }
    }
}

第三种方式可以根据需求的不同自动适应，适合具体不知道需要多少线程满足条件的情况下

public class MyThreadPoolDemo {
    public static void main(String[] args) {
		// 一池N线程，可扩容伸缩
        ExecutorService threadPool =
                Executors.newCachedThreadPool();
        try {
		// 模拟有10个顾客过来银行办理业务，池子中只有N个工作人员受理业务
            for (int i = 1; i <= 10; i++) {
				// 模拟延时看效果
				TimeUnit.SECONDS.sleep(1);
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" 办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown(); // 用完记得关闭
        }
    }
}

3、ThreadPoolExecutor 七大参数

查看上述三种线程的创建方式的底层源码，可以发现三者都共同使用ThreadPoolExecutor 类，对其进行构造器参数赋值：
newSingleThreadExecutor底层源码：

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

newFixedThreadPool(int)底层源码：

 public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

newCachedThreadPool()底层源码：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

通过比对，我们都发现本质都是调用了 new ThreadPoolExecutor ( 7 大参数 )

// 源码
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
                maximumPoolSize <= 0 ||
                maximumPoolSize < corePoolSize ||
                keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

对七个参数的解释：

• corePollSize ： 核心线程数。在创建线程后，线程池中没有任何线程，当有任务来时才创建线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中。
• maximumPoolSize： 最大线程数。表明线程中最多能够创建的线程数量。
• keepAliveTime： 空闲的线程保留的时间。
• TimeUnit： 空闲线程的保留时间单位。

TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒

• BlockingQueue< Runnable> ： 阻塞队列，存储等待执行的任务。
• ThreadFactory ： 线程工厂，用来创建线程，一般默认即可
• RejectedExecutionHandler ： 队列已满，而且任务量大于最大线程的异常处理策略。有以下取值

RejectedExecutionHandler rejected = null;
//默认，队列满了丢任务，抛出异常
rejected = new ThreadPoolExecutor.AbortPolicy();
//队列满了丢任务，不抛出异常【如果允许任务丢失这是最好的】
rejected = new ThreadPoolExecutor.DiscardPolicy();
//将最早进入队列的任务删，之后再尝试加入队列
rejected = new ThreadPoolExecutor.DiscardOldestPolicy();
//如果添加到线程池失败，那么主线程会自己去执行该任务，回退
rejected = new ThreadPoolExecutor.CallerRunsPolicy();