JAVA面试---线程池

前提知识：

进程和线程的区别:

进程是系统进行调度和分配资源的独立单位，线程是程序执行流的最小执行单位，是cup调度和分派的基本单位，线程中除了某些必要的资源外，没有其它资源。

一个程序至少有一个进程，一个进程中至少有一个线程。进程中包含了多个可同时进行的线程，同一个进程中的线程可以共享进程的资源。

线程的生命周期：

（1）创建：

第一步，用new Thread()的方法新建一个线程，在线程创建完成后，调用.start()方法，线程就进入了就绪（Runnable）状态，并没有运行。

（2）运行：
第二步，一旦得到cpu时间片，就开始执行run()方法，进入了运行状态，这里方法run()称为线程体，它包含了要执行的这个线程的内容，run方法运行结束，此线程随即终止。而如果被其他线程把CPU的执行权给抢走了，这时线程就进入到了就绪状态。而run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。

（3）阻塞：
线程中主动调用了sleep()或wait()方法时，线程会进入到阻塞状态，除此之外，当线程主动调用了阻塞时的IO方法如等待输入时，这个方法有一个返回参数，当参数返回之前，线程也会进入阻塞状态。当线程在等待某个通知的时候，也会进入到阻塞状态。当线程里的sleep()方法的睡眠时长过去后，线程就自动跳出了阻塞状态，进入到就绪状态，重新抢夺CPU。另外一种就是返回了一个参数之后，在获取到了等待的通知时，也会自动跳出线程的阻塞状态。

sleep()和wait()的主要区别在于：
1.sleep不释放对象的锁，wait(）释放对象锁
2.wait()需要在同步方法或同步代码块中使用（synchronize）
3.sleep需要捕获异常，wait不需要

（4）死亡：
在运行状态时，当完成了run方法或者非常态的调用了stop()方法之后，线程就进入了死亡状态。

单线程和多线程

单线程顾名思义就是只有一条线程在执行任务，多线程就是创建多条线程同时执行任务。

并行和并发：在我们看来都是可以同时执行多种任务，那么他们之间有什么区别呢：
并发，从宏观方面来说，就是同时进行多种时间，实际上，这几种时间并不是同时进行的，而是交替进行的，只是由于CPU的运算速度非常快，会造成我们的一种在同一时间内进行了多种事情的错觉。
并行，则是真正意义上的同时进行多种事情，这种只可以在多核CPU的基础下完成。

多线程的安全问题:

1.多个线程若同时从内存中获取了相同的资源，如i=1，这时线程A首先执行i+1操作，并且返回到了内存中，线程B而后执行i+2操作，这时内存中的i值为3，而不是4.因为线程B的结果覆盖了线程A的结果，导致线程的安全问题。
2.如果每个线程都占据了一定的资源，而且都在等待其它线程释放资源，这样就会导致死锁的发生。

线程池：

线程池的优势：

（1）降低资源消耗。通过重复利用已创建的线程来降低线程创建和销毁造成的损耗。如线程T1时间段里进行创建操作，T2时间段里进行执行操作，T3时间段里进行销毁操作，当T1+T3时间段远大于T2时间段时，使用线程池就可以有效降低创建和销毁造成的损耗。

（2）提高响应速度。当任务到达时，任务可以不需要等待线程创建就能立即执行。

（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

线程池的使用：

线程池的真正实现类是ThreadPoolExecutor，其构造方法有如下4种：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}
 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
}
 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), handler);
}
 
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.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

可以看到，其需要如下几个参数：

• corePoolSize（必需）：

核心线程数。默认情况下，核心线程会一直存活，但是当将allowCoreThreadTimeout设置为true时，核心线程也会超时回收。

• maximumPoolSize（必需）：

线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞（线程池活跃线程数达到该数值后，任务队列也已经装满了，详细可看后面）。

• keepAliveTime(必需)：

线程限制超时时长。如果超过该时长，非核心线程就会被回收，如果将allowCoreThreadTimeOut设置为true时，核心线程也会超时回收。

• unit（必需）：

指定keepAlive参数的时间单位。常用的有：TimeUnit.MILLISECONDS(毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES(分）。

• workQueue(必需)：

任务队列。通过线程池的excute()方法提交的Runnable对象将存储在该参数中。其采用阻塞队列实现，有多种阻塞队列提供选择。

• threadFactor（可选）：

线程工厂。用于指定为线程池创建新线程的方式。

• handler(可选)：

拒绝策略，当最大线程数时，需要执行的饱和策略。

线程池的使用流程：

// 创建线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,
                                             MAXIMUM_POOL_SIZE,
                                             KEEP_ALIVE,
                                             TimeUnit.SECONDS,
                                             sPoolWorkQueue,
                                             sThreadFactory);
// 向线程池提交任务
threadPool.execute(new Runnable() {
    @Override
    public void run() {
        ... // 线程执行的任务
    }
});
// 关闭线程池
threadPool.shutdown(); // 设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程
threadPool.shutdownNow(); // 设置线程池的状态为 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表

线程池的工作原理：

线程池的参数详解

（1）任务队列（workQueue）

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在Java中需要实现BlockingQueue接口。Java已经为我们提供了7仲阻塞队列的实现：
1.ArrayBlockingQueue：
一个由数组结构组成的有界阻塞队列（数组接口可配合指针形成一个环形队列）。
2.LinkedBlockingQueue：
一个由链表结构组成的有界阻塞队列，在未指明容量时，容量默认为Integer.MAX_VALUE。
3.PriorityBlockingQueue:
一个支持优先级排序的无界阻塞队列，对元素没有要求，可以实现Comparable接口也可以提供Comparator来队列中的元素进行比较。跟时间没有任何关系，仅仅是按照优先级取任务。
4.DelayQueue：
类似于PrioriyBlockingQueue，是二叉堆实现的无界优先级阻塞队列。要求元素都实现Delayed接口，通过执行时延从队列中提取任务。
5.SynchronousQueue：
一个不存储元素的阻塞队列，消费者线程调用take()方法的时候就会发生阻塞，知道有一个生产者线程生产了一个元素，消费者线程可以拿到这个元素返回；生产者线程调用put()方法的时候也会发生阻塞，直到有一个消费者线程消费了一个元素，生产者才会返回。
6.LinkedBlockingDeque：
使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样FIFO（先进先出），也可以像栈一样FILO（先进后出）。
7.LinkedTransferQueue：
它是ConcurrentLinkedQueue、LinkedBlockingQueue和SynchronousQueue的结合体，但是把它用在ThreadPoolExecutor中，和LinkedBlockingQueue行为一致，但是是无界的阻塞队列。

注意有界队列和无界队列的区别：如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置maximumPoolSize没有任何意义。

拒绝策略（handler）

当线程池的线程数达到最大线程数时，需要执行拒绝策略。拒绝策略需要实现RejectedExecutionHanler接口，并实现rejectedExcution(Runnable r , ThreadPoolExcutor excutor)方法。不过Excutros框架已经为我们实现了4种拒绝策略：
1.AbortPolicy（默认）：丢弃任务并抛出RejectedExecutionException异常。
2.CallerRunsPolicy：由调用线程处理该任务。
3.DiscardPolicy：丢弃任务，但不抛出异常。可以配合这种模式进行自定义的处理方式。
4.DiscardOldestPolicy：丢弃队列最早的未处理任务，然后重新尝试执行任务。

参考：
Java多线程：彻底搞懂线程池