关于java:看完这篇再也不怕面试官问我线程池了

在理论应用中，线程是很占用系统资源的，如果对线程治理不欠缺的话很容易导致系统问题。因而，在大多数并发框架中都会应用线程池来治理线程，应用线程池治理线程次要有如下益处：

1、应用线程池能够反复利用已有的线程继续执行工作，防止线程在创立和销毁时造成的耗费
2、因为没有线程创立和销毁时的耗费，能够进步零碎响应速度
3、通过线程能够对线程进行正当的治理，依据零碎的承受能力调整可运行线程数量的大小等

流程图：

▪ 1、比方咱们设置外围线程池的数量为 30 个，不论有没有用户连贯，咱们总是保障 30 个连贯，这个就是外围线程数，这里的外围线程数不肯定是 30 你能够依据你的需要、业务和并发访问量来设置，先判断线程池中外围线程池所有的线程是否都在执行工作，如果不是，则新创建一个线程执行刚提交的工作，否则，外围线程池中所有的线程都在执行工作，则进入第 2 步；

▪ 2、如果咱们外围线程数的 30 个数量曾经满了，就须要到阻塞队列中去查看，判断以后阻塞队列是否已满，如果未满，则将提交的工作搁置在阻塞队列中期待执行；否则，则进入第 3 步；

▪ 3、判断线程池中所有的线程是否都在执行工作，如果没有，则创立一个新的线程来执行工作，否则，则交给 饱和策略 进行解决，也叫 回绝策略，等下咱们会有具体的介绍

留神：这里有一个 外围线程数和一个线程池数量 ，这两个是不同的概念， 外围线程数 代表我可能保护罕用的线程开销，而 线程池数量 则代表我最大可能创立的线程数，例如在咱们农村每家每户都有吃水的井，基本上有 半井深的水 就能够维持咱们的日常生活的应用，这里的半井深的水就好比咱们的 外围线程数 ，还有一半的容量是咱们井可能包容的最大水资源了，超过了就不行，水就会漫出来，这个就相似于咱们的 线程池的数量，不晓得这里阐明大家是否可能更好的进行了解

1.newCachedThreadPool： 创立一个可依据须要创立新线程的线程池，然而在以前结构的线程可用时讲重用它们，并在须要时应用提供的 ThreadFactory 创立新线程

特色：

(1) 线程池中的数量没有固定，能够达到最大值（Integer.MAX_VALUE=2147483647）

(2) 线程池中的线程可进行缓存反复利用和回收（回收默认工夫为 1 分钟）

(3) 当线程池中，没有可用线程，会从新创立一个线程

2.newFixedThreadPool：创立一个可重用固定线程数的线程池，以共享的无界队列形式来运行这些线程，在任意点，在大多数 nThreads 线程会处于解决工作的活动状态。如果在所有线程处于活动状态时提交附件工作，则在有可用线程之前，附件工作将在队列中期待，如果在敞开前的执行期间因为失败而导致任何线程终止，那么一个新线程将代替它执行后续的工作（如果须要）。在某个线程被显式敞开之前，池中的线程将始终存在

特色：

(1) 线程池中的线程处于肯定的量，能够很好的控制线程的并发量

(2) 线程能够反复被应用，在显示敞开之前，都将始终存在

(3) 超过一定量的线程被提交时需在队列中期待

3.newSingleThreadExecutor：创立一个应用单个 worker 线程的 Executor，以无界队列形式来运行该线程。（留神，如果因为在敞开前的执行期间呈现失败而终止了此单个线程，那么如果须要，一个新线程将代替它执行后续的工作）。可保障程序地执行各个工作，并且在任意给定的工夫不会有多个线程是流动的，与其余等效的 newFixedThreadPool(1) 不同，可保障无需重新配置此办法所返回的执行程序即可应用其余的线程

特色：

(1) 线程池中最多执行一个线程，之后提交的线程将会排在队列中以此执行

4.newSingleThreadScheduledExecutor：创立一个单线程执行程序，它可安顿在给定提早后运行命令或者定期执行

特色：

(1) 线程池中最多执行一个线程，之后提交的线程流动将会排在队列中顺次执行

(2) 可定时或者提早执行线程流动

5.newScheduledThreadPool：创立一个线程池，它可安顿在给定提早后运行命令或者定期的执行

特色：

(1) 线程池中具备执行数量的线程，即使是空线程也将保留

(2) 可定时或者提早执行线程流动

6.newWorkStealingPool：创立一个带并行级别的线程池，并行级别决定了同一时刻最多有多少个线程在执行，如不传并行级别参数，将默认为以后零碎的 CPU 个数

咱们能够在开发工具中搜寻一个叫 Executors 的类，在外面咱们能够看到咱们下面所有的应用办法

线程工具类——Task：

public class Task implements Runnable{
    @Override
    public void run() {
        try {
            // 休眠 1 秒
            Thread.sleep(1000);
        } catch (InterruptedException e) {e.printStackTrace();
        }
        // 输入线程名
        System.out.println(Thread.currentThread().getName()+"-------running");
    }
}

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

public class CacheThreadPoolDemo {public static void main(String[] args) {ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 20; i++) {
            // 提交工作
            executorService.execute(new Task());
        }
        // 启动有序敞开，其中先前提交的工作将被执行，但不会承受任何新工作
        executorService.shutdown();}
}

后果输入：

从开始到完结咱们总共输入了 20 个 (pool-1-thread- 1 到 pool-1-thread-20 ) 线程

pool-1-thread-2-------running
pool-1-thread-6-------running
pool-1-thread-1-------running
pool-1-thread-3-------running
pool-1-thread-5-------running
pool-1-thread-4-------running
pool-1-thread-7-------running
pool-1-thread-11-------running
pool-1-thread-9-------running
pool-1-thread-10-------running
pool-1-thread-17-------running
pool-1-thread-15-------running
pool-1-thread-18-------running
pool-1-thread-16-------running
pool-1-thread-8-------running
pool-1-thread-20-------running
pool-1-thread-13-------running
pool-1-thread-19-------running
pool-1-thread-14-------running
pool-1-thread-12-------running

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

public class FixedThreadPoolDemo {public static void main(String[] args) {
        // 创立线程池，最多容许五个线程执行
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 20; i++) {
            // 提交工作
            executorService.execute(new Task());
        }
        // 启动有序敞开，其中先前提交的工作将被执行，但不会承受任何新工作
        executorService.shutdown();}
}

输入后果：

咱们能够看到其中的线程是每五个（pool-1-thread- 1 到 pool-1-thread-5）一执行，在以后执行的线程运行中，最多容许五个线程进行执行

pool-1-thread-4-------running
pool-1-thread-2-------running
pool-1-thread-1-------running
pool-1-thread-3-------running
pool-1-thread-5-------running
pool-1-thread-4-------running
pool-1-thread-5-------running
pool-1-thread-3-------running
pool-1-thread-2-------running
pool-1-thread-1-------running
pool-1-thread-4-------running
pool-1-thread-2-------running
pool-1-thread-1-------running
pool-1-thread-3-------running
pool-1-thread-5-------running
pool-1-thread-4-------running
pool-1-thread-5-------running
pool-1-thread-2-------running
pool-1-thread-1-------running
pool-1-thread-3-------running

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

public class SingleThreadPoolDemo {public static void main(String[] args) {ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 20; i++) {
            // 提交工作
            executorService.execute(new Task());
        }
        // 启动有序敞开，其中先前提交的工作将被执行，但不会承受任何新工作
        executorService.shutdown();}
}

后果输入：

咱们能够看到每次都是线程 1 输入后果

pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running
pool-1-thread-1-------running

ScheduledThreadPoolExecutor

public static void main(String[] args) {ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
//        for (int i = 0; i < 20; i++) {System.out.println(System.currentTimeMillis());
            scheduledExecutorService.schedule(new Runnable() {
                @Override
                public void run() {System.out.println("提早三秒执行");
                    System.out.println(System.currentTimeMillis());
                }
            },3, TimeUnit.SECONDS);
//        }

        scheduledExecutorService.shutdown();}

}

输入后果：

1606744468814
提早三秒执行
1606744471815

public static void main(String[] args) {ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
            scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
                int i = 1;
                @Override
                public void run() {System.out.println(i);
                    i++;
                }
            },0,1, TimeUnit.SECONDS);
//        scheduledExecutorService.shutdown();}

输入后果：

一般来说线程池只有两种状态，一种是 Running，一种是 TERMINATED，图两头的都是过渡状态

Running：能承受新提交的工作，并且也能解决阻塞队列中的工作

SHUTDOWN：敞开状态，不再承受新提交的工作，但却能够持续解决阻塞队列中已保留的工作

STOP：不能承受新工作，也不解决队列中的工作，会中断正在解决工作的线程

TIDYING：如果所有的工作都已终止了，workerCount(无效线程数)为 0. 线程池进入该状态后会调用 terminated()办法进入 TERMINATED 状态

TERMINATED：在 terminated()办法执行实现后进入该状态，默认 terminated()办法中什么也没有做

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：饱和策略（回绝策略）

ArrayBlockingQueue：

基于数组的阻塞队列实现，在 ArrayBlockingQueue 外部，保护了一个定长数组，以便缓存队列中的数据对象，这是 - 个罕用的阻塞队列，除了一个定长数组外，ArrayBlockingQueue 外部还保留着两个整形变量，别离标识着队列的头部和尾部在数组中的地位。

ArrayBlockingQueue 在生产者放入数据和消费者获取数据，都是共用同一个锁对象，由此也意味着两者无奈真正并行运行，这点尤其不同于 LinkedBlockingQueue; 依照实现原理来剖析，ArrayBlockingQueue 齐全能够采纳拆散锁，从而实现生产者和消费者操作的齐全并行运行。Doug Lea 之所以没这样去做，兴许是因为 ArrayBlockingQueue 的数据写入和获取操作曾经足够笨重，以至于引入独立的锁机制，除了给代码带来额定的复杂性外，其在性能上齐全占不到任何便宜。

ArrayBlockingQueue 和 LinkedBlockingQueue 间还有一个显著的不同之处在于，前者在插入或删除元素时不会产生或销毁任何额定的对象实例，而后者则会生成一个额定的 Node 对象。这在长时间内须要高效并发地解决大批量数据的零碎中，其对于 GC 的影响还是存在肯定的区别。而在创立 ArrayBlockingQueue 时，咱们还能够管制对象的外部锁是否采纳偏心锁，默认采纳非偏心锁。

基于链表的阻塞队列，同 ArrayListBlockingQueue 相似，其外部也维持着一个数据缓冲队列（该队列由一个链表形成)，当生产者往队列中放入一个数据时，队列会从生产者手中获取数据，并缓存在队列外部，而生产者立刻返回; 只有当队列缓冲区达到最大值缓存容量时(LinkedBlockingQueue 能够通过构造函数指定该值），才会阻塞生产者队列，直到消费者从队列中生产掉─份数据，生产者线程会被唤醒，反之对打于消费者这端的解决也基于同样的原理。而

LinkedBlockingQueue 之所以可能高效的解决并发数据，还因为其对于生产者端和消费者端别离采纳了独立的锁来控制数据同步，这也意味着在高并发的状况下生产者和消费者能够并行地操作队列中的数据，以此来进步整个队列的并发性能。

DelayQueue 中的元素只有当其指定的延迟时间到了，才可能从队列中获取到该元素。DelayQueue 是一个没有大小限度的队列，因而往队列中插入数据的操作（生产者)永远不会被阻塞，而只有获取数据的操作（消费者）才会被阻塞。

应用场景︰

DelayQueue 应用场景较少，但都相当奇妙，常见的例子比方应用一个 DelayQueue 来治理一个超时未响应的连贯队列。

基于优先级的阻塞队列（优先级的判断通过构造函数传入的 Compator 对象来决定），但须要留神的是

PriorityBlockingQueue 并不会阻塞数据生产者，而只会在没有可生产的数据时，阻塞数据的消费者。因而应用的时候要特地留神，生产者生产数据的速度相对不能快于消费者生产数据的速度，否则工夫一长，会最终耗尽所有的可用堆内存空间。在实现 PriorityBlockingQueue 时，外部控制线程同步的锁采纳的是偏心锁。

一种无缓冲的期待队列，相似于无中介的间接交易，有点像原始社会中的生产者和消费者，生产者拿着产品去集市销售给产品的最终消费者，而消费者必须亲自去集市找到所要商品的间接生产者，如果一方没有找到适合的指标，那么对不起，大家都在集市期待。绝对于有缓冲的 BlockingQueue 来说，少了一个两头经销商的环节（缓冲区），如果有经销商，生产者间接把产品零售给经销商，而无需在意经销商最终会将这些产品卖给那些消费者，因为经销商能够库存一部分商品，因而绝对于间接交易模式，总体来说采纳两头经销商的模式会吞吐量高一些(能够批量交易)﹔但另一方面，又因为经销商的引入，使得产品从生产者到消费者两头减少了额定的交易环节，单个产品的及时响应性能可能会升高。

申明一个 SynchronousQueue 有两种不同的形式，它们之间有着不太一样的行为。偏心模式和非偏心模式的区别: 如果采纳偏心模式:SynchronousQueue 会采纳偏心锁，并配合一个 FIFO 队列来阻塞多余的生产者和消费者，从而体系整体的偏心策略;

但如果是非偏心模式 (SynchronousQueue 默认) : SynchronousQueue 采纳非偏心锁，同时配合一个 LIFO 队列来治理多余的生产者和消费者，而后一种模式，如果生产者和消费者的处理速度有差距，则很容易呈现饥渴的状况，即可能有某些生产者或者是消费者的数据永远都得不到解决。

留神：

arrayblockingqueue 和 linkedblockqueue 的区别:1. 队列中锁的实现不同

1、ArrayBlockingQueue 实现的队列中的锁是没有拆散的，即生产和生产用的是同一个锁;

LinkedBlockingQueue 实现的队列中的锁是拆散的，即生产用的是 putLock，生产是 takeLock2. 队列大小初始化形式不同

2、ArrayBlockingQueue 实现的队列中必须指定队列的大小;

LinkedBlockingQueue 实现的队列中能够不指定队列的大小，然而默认是 Integer.MAX_VALUE

ThreadPoolExecutor.AbortPolicy（零碎默认）：抛弃工作并抛出 RejectedExecutionException 异样，让你感知到工作被回绝了，咱们能够依据业务逻辑抉择重试或者放弃提交等策略

ThreadPoolExecutor.DiscardPolicy：也是抛弃工作，然而不抛出异样，相对而言存在肯定的危险，因为咱们提交的时候基本不晓得这个工作会被抛弃，可能造成数据失落。

ThreadPoolExecutor.DiscardOldestPolicy：抛弃队列最后面的工作，而后从新尝试执行工作（反复此过程），通常是存活工夫最长的工作，它也存在肯定的数据失落危险

ThreadPoolExecutor.CallerRunsPolicy：由调用线程解决该工作

如果以后运行的线程少于 corePoolSize，则会创立新的线程来执行新的工作；
如果运行的线程个数等于或者大于 corePoolSize，则会将提交的工作寄存到阻塞队列 workQueue 中；
如果以后 workQueue 队列已满的话，则会创立新的线程来执行工作；
如果线程个数曾经超过了 maximumPoolSize，则会应用饱和策略 RejectedExecutionHandler 来进行解决

submit 是基办法 Executor.execute(Runnable)的延长，通过创立并返回一个 Future 类对象可用于勾销执行和 / 或期待实现。

敞开线程池，能够通过 shutdown 和 shutdownNow 两个办法
原理：遍历线程池中的所有线程，而后顺次中断
1、shutdownNow 首先将线程池的状态设置为 STOP, 而后尝试进行所有的正在执行和未执行工作的线程，并返回期待执行工作的列表；
2、shutdown 只是将线程池的状态设置为 SHUTDOWN 状态，而后中断所有没有正在执行工作的线程

如果你感觉这篇内容对你还蛮有帮忙，我想邀请你帮我三个小忙：

点赞，转发，有你们的『点赞和评论』，才是我发明的能源。
关注公众号『java 烂猪皮』，不定期分享原创常识。
同时能够期待后续文章 ing????

关于java:看完这篇再也不怕面试官问我线程池了

一、为什么须要线程池

二、工作原理

线程池执行所提交的工作过程：

三、线程池的分类

四、线程池的具体实现：ThreadPoolExecutor

4.1 newCachedThreadPool

源码实现：

案例：

4.2 newFixedThreadPool

源码实现：

案例：

4.3 newSingleThreadExecutor

源码实现：

案例：

五、线程池的具体实现：

ScheduledThreadPoolExecutor

5.1 newScheduledThreadPool

案例：

5.2 newSingleThreadScheduledExecutor

案例：

六、线程池的生命周期

七、线程池的创立

7.1 Executors 源码

7.2 参数阐明

八、阻塞队列

LinkedBlockingQueue：

DelayQueue：

PriorityBlockingQueue：

SynchronousQueue：

九、回绝策略

十、execute()和 submit()办法

10.1 execute 办法执行逻辑

10.2 Submit

十一、线程池的敞开

看完三件事❤️