时代在进步，科技在发展，hr都越来越难对付了，你呢！还停留在原地吗？
下面我个人总结了一些，java高并发堵塞队列，线程池这一系列面试问题。想拿大厂offer就跟我一起探讨一下以下问题吧。考察一个程序员功底如何，基本问一些这类问题就能了解。然而，身边小伙伴很多还原地不动，对这些面试题缺乏总结，或者很懵懂。导致面试都不是很理想，甚至吃了不少哑巴亏。作为同行我总结以下知识点，一起探讨学习。
1、堵塞队列
1.1、堵塞队列介绍
堵塞队列，顾名思义，首先它是一个队列，而一个堵塞队列在数据结构中所起的作用大致如下图所示：
线程1往阻塞队列中添加元素，而线程2从阻塞队列中移除元素
当阻塞队列是空时，从队列中获取元素的操作将会被阻塞。
当阻塞队列是满时，往队列里添加元素的操作将会被阻塞。
试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。
同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程从列中移除一个或者多个元素或者完全清空队列后使队列重新变得空闲起来并后续新增。
1.2、使用堵塞队列的好处
在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会被自动被唤醒。使用BlockingQueue的好处时我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue都给你一手包办了。
在Concurrent包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。
1.3、堵塞队列种类
ArrayBlockingQueue: 由数组结构组成的有界阻塞队列。
LinkedBlockingQueue:由链表结构组成的有界（但大小默认值为Integer.MAX_VALUE）阻塞队列。
PriorityBlockingQueue: 支持优先级排序的无界阻塞队列。
DelayQueue: 使用优先级队列实现的延迟无界阻塞队列。
SynchronousQueue:不存储元素的阻塞队列，也即单个元素的队列。
LinkedTransferQueue:由链表结构组成的无界阻塞队列。
LinkedBlockingDeque:由链表结构组成的双向阻塞队列。
1.4、堵塞队列核心方法
| 方法类型 | 抛出异常 | 特殊值 | 阻塞 | 超时 |
|---|---|---|---|---|
| 插入 | add(e) | offer(e) | put(e) | offer(e,time,unit) |
| 移除 | remove() | poll() | take() | poll(time,unit) |
| 检查 | element() | peek() | 不可用 | 不可用 |
| 抛出异常 | 当阻塞队列满时，再往队列里add插入元素会抛egalStateException:Queue full。 当阻塞队列空时，再往队列里remove移除元素会抛NoSuchElementException |
|---|---|
| 特殊值 | 插入方法，成功ture失败false。 移除方法，成功返回出队列的元素。队列里面没有就返回null |
| 一直阻塞 | 当阻塞队列满时，生产者线程继续往队列里put元素，队列会一直阻塞生产线程直到put数据or响应中断退出。 当阻塞队列空时，消费者线程视图从队列里take元素，队列会一直阻塞消费者线程直到队列可用。 |
| 超时退出 | 当阻塞队列满时，队列会阻塞生产者线程一定时间，超过后限时后生产者线程会退出。 |
1.5、使用实例
1.5.1、抛出异常组
代码展示如下：再往队列里add插入元素会抛egalStateException:Queue full,再往队列里remove移除元素会抛NoSuchElementException
public class BlockingQueueDemo {
public static void main(String[] args) {
BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.add("a"));
System.out.println(blockingQueue.add("b"));
System.out.println(blockingQueue.add("c"));
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
System.out.println(blockingQueue.remove());
}
}
执行结果：一有问题直接抛异常，如下图所示。
true true true a b c Exception in thread "main" java.util.NoSuchElementException at java.util.AbstractQueue.remove(AbstractQueue.java:117) at com.kind.kindcryptodome.BlockingQueueDemo.main(BlockingQueueDemo.java:16)
1.5.2、特殊值
代码展示如下:插入方法，成功ture失败false。
public class BlockingQueueDemo {
public static void main(String[] args) {
BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.offer("a"));
System.out.println(blockingQueue.offer("b"));
System.out.println(blockingQueue.offer("c"));
System.out.println(blockingQueue.offer("d"));
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
System.out.println(blockingQueue.poll());
}
}
执行结果：
true true true false a b c null xxxxxxxxxx11 1true2true3true4false5a6b7c8nulltrue9true10true11false
1.5.3、阻塞
展示代码如下:当阻塞队列满时，生产者线程继续往队列里put元素，队列会一直阻塞生产线程直到put数据or响应中断退出。
public class BlockingQueueDemo {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
blockingQueue.put("a");
blockingQueue.put("a");
blockingQueue.put("a");
//blockingQueue.put("a");
System.out.println("=====================");
blockingQueue.take();
blockingQueue.take();
blockingQueue.take();
blockingQueue.take();
}
}
执行结果：消费者线程视图从队列里take元素，队列会一直阻塞消费者线程直到队列可用.
=====================
1.5.4、超时
展示代码如下:当阻塞队列满时，队列会阻塞生产者线程一定时间，超过后限时后生产者线程会退出
public class BlockingQueueDemo {
public static void main(String[] args) throws InterruptedException {
BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(3);
System.out.println(blockingQueue.offer("a", 2L, TimeUnit.SECONDS));
System.out.println(blockingQueue.offer("b", 2L, TimeUnit.SECONDS));
System.out.println(blockingQueue.offer("c", 2L, TimeUnit.SECONDS));
System.out.println(blockingQueue.offer("d", 2L, TimeUnit.SECONDS));
}
}
执行结果：
true true true false
1.6、同步堵塞队列
SynchronousQueue没有容量。
与其他BlockingQueue不同，SynchronousQueue是一个不存存储元素的BlockingQueue。
每一个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然。
展示代码如下：
public class SynchronousQueue {
public static void main(String[] args) {
BlockingQueue<String> blockingQueue = new java.util.concurrent.SynchronousQueue<>();
new Thread(() -> {
try {
System.out.println(Thread.currentThread().getName()+"\t put 1");
blockingQueue.put("1");
System.out.println(Thread.currentThread().getName()+"\t put 2");
blockingQueue.put("2");
System.out.println(Thread.currentThread().getName()+"\t put 3");
blockingQueue.put("3");
}catch (Exception e){
e.printStackTrace();
}
},"T1").start();
new Thread(() -> {
try{
TimeUnit.SECONDS.sleep(5);
System.out.println(Thread.currentThread().getName()+"\t"+blockingQueue.take());
TimeUnit.SECONDS.sleep(5);
System.out.println(Thread.currentThread().getName()+"\t"+blockingQueue.take());
TimeUnit.SECONDS.sleep(5);
System.out.println(Thread.currentThread().getName()+"\t"+blockingQueue.take());
}catch (Exception e){
e.printStackTrace();
}
},"T2").start();
}
}
执行结果：
T1 put 1 T2 1 T1 put 2 T2 2 T1 put 3 T2 3
1.7、线程实现生产者消耗者
传统版代码展示：
public class ShareData {
private int number = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void increment()throws Exception{
lock.lock();
try {
while (number != 0){
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName()+"\t"+number);
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void decrement()throws Exception{
lock.lock();
try {
while (number == 0){
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName()+"\t"+number);
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public static void main(String[] args) {
ShareData shareData = new ShareData();
new Thread(() ->{
for (int i = 0; i <5 ; i++) {
try {
shareData.increment();
}catch (Exception e){
e.printStackTrace();
}
}
},"T3").start();
new Thread(() ->{
for (int i = 0; i <5 ; i++) {
try {
shareData.decrement();
}catch (Exception e){
e.printStackTrace();
}
}
},"T4").start();
}
}
执行结果：
T3 1 T4 0 T3 1 T4 0 T3 1 T4 0 T3 1 T4 0 T3 1 T4 0
升级版代码展示:不需写锁，直接用原子整型方法，BlockingQueue队列，实现一个生产一个消费。
class MyResourceDemo {
private volatile boolean FLAG = true;
private AtomicInteger atomicInteger = new AtomicInteger();
BlockingQueue<String> blockingQueue = null;
public MyResourceDemo(BlockingQueue<String> blockingQueue){
this.blockingQueue = blockingQueue;
System.out.println(blockingQueue.getClass().getName());
}
public void myProd()throws Exception{
String data = null;
boolean retValue;
while (FLAG){
data = atomicInteger.incrementAndGet()+"";
retValue = blockingQueue.offer(data,2L, TimeUnit.SECONDS);
if(retValue){
System.out.println(Thread.currentThread().getName()+"\t 插入数据"+data+"成功");
}else {
System.out.println(Thread.currentThread().getName()+"\t 插入数据"+data+"失败");
}
TimeUnit.SECONDS.sleep(1);
}
System.out.println(Thread.currentThread().getName()+"\t 表示FLAG=false,结束生产");
}
public void myConsumer()throws Exception{
String result = null;
String retValue;
while (FLAG){
result = blockingQueue.poll(2L, TimeUnit.SECONDS);
if(null == result || result.equalsIgnoreCase("")){
FLAG = false;
System.out.println(Thread.currentThread().getName()+"\t 表示超时,结束消费");
return;
}
System.out.println(Thread.currentThread().getName()+"\t 消费数据成功");
}
}
public void stop()throws Exception{
FLAG = false;
}
}
public class MyResource {
public static void main(String[] args) throws Exception {
MyResourceDemo myResourceDemo = new MyResourceDemo(new ArrayBlockingQueue<>(10));
new Thread(() ->{
System.out.println(Thread.currentThread().getName() + "\t 生产线程启动");
try {
myResourceDemo.myProd();
} catch (Exception e) {
e.printStackTrace();
}
},"T1").start();
new Thread(() ->{
System.out.println(Thread.currentThread().getName() + "\t 消费线程启动");
try {
myResourceDemo.myConsumer();
} catch (Exception e) {
e.printStackTrace();
}
},"T2").start();
TimeUnit.SECONDS.sleep(5);
myResourceDemo.stop();
System.out.println(Thread.currentThread().getName() + "\t 线程结束");
}
}
执行结果:
java.util.concurrent.ArrayBlockingQueue T1 生产线程启动 T1 插入数据1成功 T2 消费线程启动 T2 消费数据成功 T1 插入数据2成功 T2 消费数据成功 T1 插入数据3成功 T2 消费数据成功 T1 插入数据4成功 T2 消费数据成功 T1 插入数据5成功 T2 消费数据成功 main 线程结束 T1 表示FLAG=false,结束生产 T2 表示超时,结束消费
2、线程池
2.1、线程池及优势
-
线程池做的工作主要是控制运行的线程数量，处理过程中将任务放入队列，然后在线程创建后启动这些任务，如果线程数量超过了最大数量超出数量的线程排队等候，等其它线程执行完毕，再从队列中取出任务来执行。
-
他的主要特点为，线程复用，控制最大并发数，管理线程。
-
第一、降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
-
第二、提高响应数度，当任务到达时，任务可以不需要的等到线程创建就能立即执行。
-
第三、提高线程的可管理性，线程时稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
-
2.2、线程池三个常用方式
2.2.1、Executors.newFixedThreadPool(int)
-
主要特点如下：
-
执行长期的任务，性能好很多。
-
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
-
newFixedThreadPool创建的线程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue;
-
2.2.2、Executors.newSingleThreadExecutor()
-
主要特点如下:
-
使用在一个任务一个任务执行的场景
-
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。
-
newSingleThreadExecutor将corePoolSize和maximumPoolSize都设置为1，它使用的LinkedBlockingQueue
-
2.2.3、Executors.newCachedThreadPool()
-
主要特点如下：
-
执行很多短期异步的小程序或者负载较轻的服务。
-
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若午可回收，则新建线程。
-
newCachedThreadPool将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue,也就是说来了任务就创建线程运行，当线程空闲超过60秒，就销毁线程。
使用案例代码展示：
public class MyThreadPoolDemo { public static void main(String[] args) { //ExecutorService threadPool = Executors.newFixedThreadPool(3); //ExecutorService threadPool = Executors.newSingleThreadExecutor(); ExecutorService threadPool = Executors.newCachedThreadPool(); try { for (int i = 0; i < 10; i++) { threadPool.execute(() ->{ System.out.println(Thread.currentThread().getName()+"\t 添加数据"); }); } } catch (Exception e) { e.printStackTrace(); }finally { threadPool.shutdown(); } } } -
2.2.4、线程池实际中使用哪一个
-
以上都不许用，原因如下：
-
并发处理
-
{强制}获取单例对象需要保证线程安全，其中的方法也要保证线程安全。
-
说明：资源驱动类，工具类，单例工厂类都需要注意。
-
-
{强制}创建线程或线程池时请指定有意义的线程名称，方便出错时回溯。
-
{强制}线程资源必须通过线程池提供，不允许再应用中自行显式创建线程。
-
说明：使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销，解决资源不足的问题，如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者过度切换的问题。
-
-
{强制}线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。
-
说明：Executors返回的线程池对象的弊端如下：
-
FixedThreadPool和SingLeThreadPool:
-
允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
-
-
CachedThreadPool和ScheduledThreadPool:
-
允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程，从而导致OOM。
-
-
-
-
2.3、线程池的7大参数
2.3.1、corePoolSize:线程池中的常驻核心线程数
-
在创建了线程池后，当有请求任务来之后，就会安排池中的线程去执行请求任务，近似理解为今日当值线程。
-
当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中。
2.3.2、maximumPoolSize：线程池能够容纳同时执行的最大线程数
-
此值必须大于等于1。
2.3.3、KeepAliveTime: 多余的空闲线程的存活时间
-
当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime值时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。
2.3.4、unit:keepAliveTime的单位。
-
设置时间的单位。只有当线程池中的线程数大于corePoolSize时keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize。
2.3.5、workQueue：任务队列，被提交但尚未被执行的任务。
-
阻塞队列。
2.3.6、threadFactory:表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可
2.3.7、handler:拒绝策略，表示当前队列满了并且工作线程大于等于线程池的最大线程数（maximumPoolSize）时如何来拒绝请求执行的runnable的策略
2.4、线程池原理
-
在创建了线程池后，等待提交过来的任务请求。
-
当调用execute()方法添加一个请求任务时，线程池会做如下判断：
-
如果正在运行的线程数量小于corePoolSize,那么马上创建线程运行这个任务。
-
如果正在运行的线程数量大于或等于corePoolSize,那么将这个任务放入队列。
-
如果这时候队列满了且正在运行的线程数量还小于maximumpoolSize,那么还是要创建非核心线程立刻运行这个任务。
-
如果队列满了且正在运行的线程数量大于或等于maximumPoolSize,那么线程池会启动饱和和拒绝策略来执行
-
-
当一个线程完成任务时，它会从队列中取下一个任务来执行。
-
当一个线程无事可做超过一定的时间（KeepAliveTime）时，线程池会判断。
-
如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。
-
所以线程池的所有任务完成后它最终会收缩到corePoolSize的大小。
-
2.5、线程池的拒绝策略
2.5.1、拒绝策略介绍
-
等待队列也已经排满了，再也赛不下新任务了。
-
同时，线程池中的max线程也达到了，无法继续为新任务服务。
-
这时候我们就需要拒绝策略机制合理的处理这个问题。
2.5.2、JDK内置拒绝策略四种状态
-
AbortPolicy(默认):直接抛出RejectedExecutionException异常阻止系统正常运行。
-
CallerRunsPolicy：调用者运行一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
-
DiscardOldestPolicy:抛弃队列种等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务。
-
DiscardPolicy：直接丢弃任务，不予任何处理也不抛出异常，如果允许任务丢失，这是最后的一种方案。
2.6、线程池案例与合理配置线程数
-
创建线程池使用案例
public class MyThreadPoolDemo1 {
public static void main(String[] args) {
ExecutorService threadPool = new ThreadPoolExecutor(2, 5, 1L,TimeUnit.SECONDS, new LinkedBlockingQueue<>(3), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
try {
for (int i = 0; i < 9; i++) {
threadPool.execute(() ->{
System.out.println(Thread.currentThread().getName()+"\t 添加数据");
});
}
} catch (Exception e) {
e.printStackTrace();
}finally {
threadPool.shutdown();
}
}
}
-
合理配置线程池
-
CPU密集型
-
CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。
-
CPU密集任务只有在真正的多核CPU上才可能得到加速（通过多线程）。
-
CPU密集型任务配置尽可能少的线程数量：一般公式：CPU核数+1个线程的线程池。
-
java获取CPU核数代码如下：
System.out.println(Runtime.getRuntime().availableProcessors());
-
IO密集型
-
IO密集型，即该任务需要大量的IO,即大量的阻塞。
-
在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待。
-
所以在IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。
-
IO密集型时，大部分线程都阻塞，故需要多配置线程数：
-
参考公式：CPU核数/1-阻塞系数 阻塞系数在0.8-0.9之间
-
比如8核CPU: 8/1-0.9=80个线程数
-
-
-
3、小结
到这里我们也了解一些java高并发堵塞队列线程池等相关知识，以上代码讲解的只是一小部分，面试是一个大工程。我们需要不断的去深入，不断的去探索，结合实际才能更快的掌握相关知识。之前还有总结一些高并发集合类，我觉得都是面试者必经之路。同时希望以上内容对你有所帮助，总结的不到位希望小伙伴们一起探讨。
404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
