java线程池

参考博文：

https://blog.csdn.net/programmer_at/article/details/79799267

https://blog.csdn.net/qq_33300570/article/details/78394188

https://www.jianshu.com/p/87bff5cc8d8c

https://blog.csdn.net/hzw19920329/article/details/52372348

 

 

ThreadPoolExecutor提交任务有两种方法：

ThreadPoolExecutor executor =

new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5));

 

第一种提交方式：

executor.execute(myTask);
程序执行流程：

execute()----->addWorker()----->new Worker(firstTask)----->this.thread = getThreadFactory().newThread(this)----->

Thread t = w.thread------>workers.add(w)------>t.start()----->public void run()[Worker类中] ------>runWorker(this)------>

task.run() [自己定义的任务类，实现了Runnable接口]------>task = getTask()------>

Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();

1、workQueue.take：如果阻塞队列为空，当前线程会被挂起等待；当队列中有任务加入时，线程被唤醒，take方法返回任务，并执行；
2、workQueue.poll：如果在keepAliveTime时间内，阻塞队列还是没有任务，则返回null；

所以，线程池中实现的线程可以一直执行由用户提交的任务。

 

第二种方式：

 

 

Future<String> future = executor.submit(new MyTask(i));

try {
                String result = future.get();  //会阻塞主线程
                System.out.println(result);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ExecutionException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

程序执行流程：

executor.submit(new MyTask(i))----->RunnableFuture<T> ftask = newTaskFor(task)[得到FutureTask对象]----->

new FutureTask<T>(callable) [this.callable = callable; this.state = NEW;] ------>execute(ftask)------>类似于第一种方式将线程提交到线程池，然后执行FutureTask的run方法----->Callable<V> c = callable----->result = c.call() [自己定义的任务]----->set(result)[将结果过封装到ftask]----->String result = future.get()------>return report(s);

 

 

1.通过submit方法提交的Callable任务会被封装成了一个FutureTask对象。

2.FutureTask在不同阶段拥有不同的状态state，初始化为NEW；
3.FutureTask类实现了Runnable接口，这样就可以通过Executor.execute方法提交FutureTask到线程池中等待被执行，最终执行的是FutureTask的run方法；

FutureTask.run方法是在线程池中被执行的，而非主线程
1、通过执行Callable任务的call方法；
2、如果call执行成功，则通过set方法保存结果；
3、如果call执行有异常，则通过setException保存异常；

set和setException方法中，都会通过UnSAFE修改FutureTask的状态，并执行finishCompletion方法通知主线程任务已经执行完成；

 

1、执行FutureTask类的get方法时，会把主线程封装成WaitNode节点并保存在waiters链表中；
2、FutureTask任务执行完成后，通过UNSAFE设置waiters的值，并通过LockSupport类unpark方法唤醒主线程；

 

1、如果主线程被中断，则抛出中断异常；
2、判断FutureTask当前的state，如果大于COMPLETING，说明任务已经执行完成，则直接返回；
3、如果当前state等于COMPLETING，说明任务已经执行完，这时主线程只需通过yield方法让出cpu资源，等待state变成NORMAL；
4、通过WaitNode类封装当前线程，并通过UNSAFE添加到waiters链表；
5、最终通过LockSupport的park或parkNanos挂起线程；

面试问题：
1、线程池存在哪些状态；

其中AtomicInteger变量ctl的功能非常强大：利用低29位表示线程池中线程数，通过高3位表示线程池的运行状态： 
1、RUNNING：-1 << COUNT_BITS，即高3位为111，该状态的线程池会接收新任务，并处理阻塞队列中的任务； 
2、SHUTDOWN： 0 << COUNT_BITS，即高3位为000，该状态的线程池不会接收新任务，但会处理阻塞队列中的任务； 
3、STOP ： 1 << COUNT_BITS，即高3位为001，该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务； 
4、TIDYING ： 2 << COUNT_BITS，即高3位为010, 所有的任务都已经终止； 
5、TERMINATED： 3 << COUNT_BITS，即高3位为011, terminated()方法已经执行完成 

<1>Running：可以接受新任务，同时也可以处理阻塞队列里面的任务；

<2>Shutdown：不可以接受新任务，但是可以处理阻塞队列里面的任务；

<3>Stop：不可以接受新任务，也不处理阻塞队列里面的任务，同时还中断正在处理的任务；

<4>Tidying：属于过渡阶段，在这个阶段表示所有的任务已经执行结束了，当前线程池中是不存在有效的线程的，并且将要调用terminated方法；

<5>Terminated：终止状态，这个状态是在调用完terminated方法之后所处的状态；

2、线程池的种类：

(1)：CachedThreadPool：缓存线程池，该类线程池中线程的数量是不确定的，理论上可以达到Integer.MAX_VALUE个，这种线程池中的线程都是非核心线程，既然是非核心线程，那么就存在超时淘汰机制了，当里面的某个线程空闲时间超过了设定的超时时间的话，就会回收掉该线程；

1. 线程池的线程数可达到Integer.MAX_VALUE，即2147483647，内部使用SynchronousQueue作为阻塞队列；
2. 和newFixedThreadPool创建的线程池不同，newCachedThreadPool在没有任务执行时，当线程的空闲时间超过keepAliveTime，会自动释放线程资源，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；

执行过程与前两种稍微不同: 
(1) 主线程调用SynchronousQueue的offer()方法放入task, 倘若此时线程池中有空闲的线程尝试读取 SynchronousQueue的task, 即调用了SynchronousQueue的poll(), 那么主线程将该task交给空闲线程. 否则执行(2) 
(2) 当线程池为空或者没有空闲的线程, 则创建新的线程执行任务. 
(3) 执行完任务的线程倘若在60s内仍空闲, 则会被终止. 因此长时间空闲的CachedThreadPool不会持有任何线程资源.

     (2)：FixedThreadPool：固定线程池，这类线程池中是只存在核心线程的，对于核心线程来说，如果我们不设置allowCoreThreadTimeOut属性的话是不存在超时淘汰机制的，这类线程池中的corePoolSize的大小是等于maximumPoolSize大小的，也就是说，如果线程池中的线程都处于活动状态的话，如果有新任务到来，他是不会开辟新的工作线程来处理这些任务的，只能将这些任务放到阻塞队列里面进行等到，直到有核心线程空闲为止；

缺点：FixedThreadPool的工作队列为无界队列LinkedBlockingQueue(队列容量为Integer.MAX_VALUE), 这会导致以下问题: 
- 线程池里的线程数量不超过corePoolSize,这导致了maximumPoolSize和keepAliveTime将会是个无用参数 
- 由于使用了无界队列, 所以FixedThreadPool永远不会拒绝, 即饱和策略失效

        (3)：ScheduledThreadPool：任务线程池，这种线程池中核心线程的数量是固定的，而对于非核心线程的数量是不限制的，同时对于非核心线程是存在超时淘汰机制的，主要适用于执行定时任务或者周期性任务的场景；

        (4)：SingleThreadPool：单一线程池，线程池里面只有一个线程，同时也不存在非核心线程，感觉像是FixedThreadPool的特殊版本，他主要用于确保任务在同一线程中的顺序执行，有点类似于进行同步吧；

初始化的线程池中只有一个线程，如果该线程异常结束，会重新创建一个新的线程继续执行任务，唯一的线程可以保证所提交任务的顺序执行.

由于使用了无界队列, 所以SingleThreadPool永远不会拒绝, 即饱和策略失效

3、线程运行流程：

 我们可以调用submit或者execute方法，两者最大的区别在于，调用submit方法的话，我们可以传入一个实现Callable接口的对象，进而能在当前任务执行结束之后通过Future对象获得任务的返回值，submit内部实际上还是执行的execute方法；而调用execute方法的话，是不能获得任务执行结束之后的返回值的；此外，调用submit方法的话是可以抛出异常的，但是调用execute方法的话，异常在其内部得到了消化，也就是说异常在其内部得到了处理，不会向外传递的；

        因为submit方法最终也是会执行execute方法的，因此我们只需要了解execute方法就可以了：

具体流程参考上面有详细分析。

实际上是在addWorker方法里面检查当前线程池中的线程数量有没有超过maximumPoolSize。

4、线程池是怎么做到重用线程的呢？

个人认为线程池里面重用线程的工作是在getTask里面实现的，在getTask里面是存在两个for死循环嵌套的，他会不断的从阻塞对列里面取出需要执行的任务，返回给我们的runWorker方法里面，而在runWorker方法里面只要getTask返回的任务不是空就会执行该任务的run方法来处理它，这样一直执行下去，直到getTask返回空为止，此时的情况就是阻塞队列里面没有任务了，这样一个线程处理完一个任务之后接着再处理阻塞队列中的另一个任务，当然在线程池中的不同线程是可以并发处理阻塞队列中的任务的，最后在阻塞队列内部不存在任务的时候会去判断是否需要回收Worker对象，其实Worker对象的个数就是线程池中线程的个数，至于什么情况才需要回收，就是四种情况了：

在Worker必须需要退出的情况下getTask会返回空，具体什么情况下Worker会退出呢？(1)：当Worker的数量超过maximumPoolSize的时候；(2)：当线程池状态为Stop的时候；(3)：当线程池状态为Shutdown并且阻塞队列为空的时候；(4)：使用等待超时时间从阻塞队列中拿数据，但是超时之后仍然没有拿到数据；

注意一个线程会执行多个task，直到getTask()返回为null，会跳出 while循环，继续执行processWorkerExit(w, completedAbruptly);  将w从hashSet中移除(移除后线程也被移除了，难道矛盾吗？？？？，no！！！如上只有4中情况回会返回null，所以不会矛盾)。

       最后就是线程池是怎样被关闭的呢？

        涉及到线程池的关闭，需要用到两个方法，shutdown和shutdownNow，他们都是位于ThreadPoolExecutor里面的，对于shutdown的话，他会将线程池状态切换成Shutdown，此时是不会影响对阻塞队列中任务执行的，但是会拒绝执行新加进来的任务，同时会回收闲置的Worker；而shutdownNow方法会将线程池状态切换成Stop，此时既不会再去处理阻塞队列里面的任务，也不会去处理新加进来的任务，同时会回收所有Worker；