JUC 高并发编程(3)：阻塞队列，线程池

最新推荐文章于 2024-07-21 22:03:26 发布
最新推荐文章于 2024-07-21 22:03:26 发布
阅读量215 收藏 1
点赞数
分类专栏： JUC 高并发编程 文章标签： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_tianyanxiaobai/article/details/119448353
版权

阻塞队列

阻塞队列概述

定义：

  • 当阻塞队列是空时,从队列中获取元素的操作将会被阻塞
  • 当阻塞队列是满时,往队列中添加元素的操作将会被阻塞
    在这里插入图片描述

用处

  • 是我们不需要关心什么时候需要阻塞线程,什么时候需要唤醒线程,因为 BlockingQueue 都一手给你包办好了
  • 在concurrent包发布以前,在多线程环境下,我们每个程序员都必须自己去控制这些细节,尤其还要兼顾效率和线程安全,而这会给我们的程序带来不小的复杂度.

架构介绍
在这里插入图片描述

阻塞队列种类

  • ①. ArrayBlockingQueue: 由数组结构组成的有界阻塞队列

  • ②.LinkedBlockingQueue: 由链表结构组成的有界(但大小默认值 Integer>MAX_VAL UE) 阻塞队列.

  • ③. SynchronousQueue: 不存储元素的阻塞队列, 也就是单个元素的队列.

    • SynchronousQueue是无界的，是一种无缓冲的等待队列，但是由于该Queue本身的特性，在某次添加元素后必须等待其他线程取走后才能继续添加；
    • 可以认为 SynchronousQueue 是一个缓存值为1的阻塞队列，但是 isEmpty() 方法永远返回是true，remainingCapacity() 方法永远返回是0，remove() 和removeAll() 方法永远返回是false，iterator()方法永远返回空，peek()方法永远返回null。
    • 例子
      public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new 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 (InterruptedException e) {
                e.printStackTrace();
            }
        }, "AAA").start();

        new Thread(() -> {
            try {
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "BBB").start();
    }
}
      结果显示：
      在这里插入图片描述

  • ④. PriorityBlockingQueue: 支持优先级排序的无界阻塞队列.

  • ⑤. LinkedTransferQueue: 由链表结构组成的无界阻塞队列.

  • ⑥. LinkedBlockingDeque: 由了解结构组成的双向阻塞队列.

BlockingQueue的核心方法

在这里插入图片描述
在这里插入图片描述
例子： 演示阻塞队列满了后的情况

public class BlockingQueueExceptionDemo {
    public static void main(String[] args) {
        //List list=new ArrayList();
        //注意:这里要给一个初始值
        BlockingQueue<String>blockingQueue=new ArrayBlockingQueue<>(3);
        //add() 方法是给ArrayBlockingQueue添加元素,如果超过会抛出异常!
        System.out.println(blockingQueue.add("a"));//true
        System.out.println(blockingQueue.add("b"));//true
        System.out.println(blockingQueue.add("c"));//true
        //element是检查元素有没有? 检查的是出栈的元素
        blockingQueue.element();

        //remove()
        System.out.println(blockingQueue.remove());//a
        System.out.println(blockingQueue.remove());//b
        System.out.println(blockingQueue.remove());//c
    }
}
    @Test
    public void offerAndPoll()throws Exception{
        BlockingQueue blockingQueue=new ArrayBlockingQueue(3);
        //前三个直接成功
        System.out.println(blockingQueue.offer("a", 2L, TimeUnit.SECONDS));
        System.out.println(blockingQueue.offer("a", 2L, TimeUnit.SECONDS));
        System.out.println(blockingQueue.offer("a", 2L, TimeUnit.SECONDS));
        //下面这个会阻塞2s
        System.out.println(blockingQueue.offer("a", 2L, TimeUnit.SECONDS));
    }

结果：
前三个直接输出，最后一个会阻塞两秒，再输出。

线程池

线程池做的工作主要是控制运行的线程的数量,处理过程中将任务加入队列,然后在线程创建后启动这些任务,

  • 如果显示超过了最大数量，超出的数量的线程排队等候,等其他线程执行完毕,再从队列中取出任务来执行
  • 它的主要特点为:线程复用 | 控制最大并发数 | 管理线程

ThreadPoolExecutor

Java中的线程池是通过Executor框架实现的,该框架中用到了Executor,Executors,ExecutorService,ThreadPoolExecutor这几个类，如下图：
在这里插入图片描述

线程池的创建
Executor 的接口方法中存在三种创建线程池的方法如下：

  • Executors.newFixedThreadPool(int) : 创建定长线程池（一池定线程）
    在这里插入图片描述

  • Executors.newSingleThreadExecutor( ): 一池一线程,保证任务的顺序执行
    在这里插入图片描述

  • Executors.newCachedThreadPool( ) ： 创建可灵活改变大小的线程，一池N线程
    在这里插入图片描述
    在这里插入图片描述

例子如下：

/*
//看cpu的核数
//System.out.println(Runtime.getRuntime().availableProcessors());
* 第四种获取/使用java多线程的方式,线程池
* */
public class ExecutorTest {
    public static void main(String[] args) {

        //ExecutorService threadPool= Executors.newFixedThreadPool(5);//一池5个处理线程
        //ExecutorService threadPool=Executors.newSingleThreadExecutor();//一池一线程
        ExecutorService threadPool=Executors.newCachedThreadPool();//一池N线程

        try {
            for (int i = 1; i <= 10; i++) {
                //使用
                threadPool.execute(() -> {
                    //模拟10个用户来办理业务,每个用户就是一个来自外部的请求线程
                    System.out.println(Thread.currentThread().getName() + "\t 办理业务~！");
                });
                //try { TimeUnit.SECONDS.sleep(3);  } catch (InterruptedException e) {e.printStackTrace();}
            }

        }catch (Exception e){

        }finally {
            //关闭
            threadPool.shutdown();
        }
    }
}

  • 一池N线程结果：

    pool-1-thread-2	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-3	 办理业务~！
pool-1-thread-4	 办理业务~！
pool-1-thread-5	 办理业务~！
pool-1-thread-6	 办理业务~！
pool-1-thread-7	 办理业务~！
pool-1-thread-9	 办理业务~！
pool-1-thread-8	 办理业务~！

  • 一池 5线程结果

    pool-1-thread-1	 办理业务~！
pool-1-thread-2	 办理业务~！
pool-1-thread-2	 办理业务~！
pool-1-thread-2	 办理业务~！
pool-1-thread-2	 办理业务~！
pool-1-thread-2	 办理业务~！
pool-1-thread-3	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-4	 办理业务~！
pool-1-thread-5	 办理业务~！

  • 一池一线程结果：

    pool-1-thread-1	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-1	 办理业务~！
pool-1-thread-1	 办理业务~！

线程池的七大参数

①. corePoolSize: 线程池中的常驻核心线程数。

  • 在创建了线程池后,当有请求任务来之后,就会安排池中的线程去执行请求任务,近似理解为今日当值线程
  • 当线程池中的线程数目达到corePoolSize后,就会把到达的任务放入到缓存队列当中.

②. maximumPoolSize: 线程池能够容纳同时执行的最大线程数,此值大于等于1

③. keepAliveTime: 多余的空闲线程存活时间

  • 当线程超过 corePoolsize 时，其他
  • 当空间时间达到keepAliveTime值时,多余的线程会被销毁直到只剩下corePoolSize个线程为止(非核心线程)
  • unit: keepAliveTime的单位

⑤. workQueue: 任务队列,被提交但尚未被执行的任务(候客区)

⑥.threadFactory: 表示生成线程池中工作线程的线程工厂,

  • 用户创建新线程,一般用默认即可(银行网站的logo | 工作人员的制服 | 胸卡等)

⑦. handler:拒绝策略

  • 表示当线程队列满了并且工作线程大于等于线程池的最大显示 数(maxnumPoolSize)时如何来拒绝

形象化的理解：
在这里插入图片描述

在这里插入图片描述

线程池的底层工作原理

在这里插入图片描述
在这里插入图片描述

线程池的拒绝策略请你谈谈

等待队列也已经排满了,再也塞不下新的任务了。同时,线程池的maximumPoolSize也到达了,无法接续为新任务服务,这时我们需要拒绝策略机制合理的处理这个问题。

  • AbortPolicy(默认):直接抛出RejectedException异常阻止系统正常运行
  • CallerRunsPolicy: "调用者运行"一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是返回给调用者进行处理
  • DiscardOldestPolicy: 将最早进入队列的任务删除,之后再尝试加入队列
  • DiscardPolicy: 直接丢弃任务,不予任何处理也不抛出异常.如果允许任务丢失,这是最好的拒绝策略

以上内置策略均实现了RejectExecutionHandler接口

单一的/固定数的/可变你的三种创建线程池的方法,你用哪个多?

答案 ：一个都不用,我们生产上只能使用自定义的。

参考阿里巴巴java开发手册
【强制】线程资源必须通过线程池提供,不允许在应用中自行显式创建线程。 说明:使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销,解决资源不足的问题。如果不使用线程池,有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。
【强制】==线程池不允许使用Executors去创建,而是通过ThreadPoolExecutor的方式,==这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。

说明:Executors返回的线程池对象的弊端如下:

  • (1). FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求,从而导致OOM。
  • (2). CachedThreadPool和ScheduledThreadPool:允许的创建线程数量为Integer.MAX_VALUE,可能会创建大量的线程,从而导致OOM。

自定义创建线程池的方法

利用 常见线程池，

    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 class MyThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>(3),
                Executors.defaultThreadFactory(),
                //默认抛出异常
                //new ThreadPoolExecutor.AbortPolicy()
                //回退调用者
                //new ThreadPoolExecutor.CallerRunsPolicy()
                //处理不来的不处理,丢弃时间最长的
                //new ThreadPoolExecutor.DiscardOldestPolicy()
                //直接丢弃任务,不予任何处理也不抛出异常
                new ThreadPoolExecutor.DiscardPolicy()
        );
        //模拟10个用户来办理业务 没有用户就是来自外部的请求线程.
        try {
            for (int i = 1; i <= 10; i++) {
                threadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "\t 办理业务");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
        //threadPoolInit();
    }
}

上面代码由于拒绝策略不同，得到的结果也是不同的：

  • ①. AbortPolicy: 最大不会抛出异常的值= maximumPoolSize + new LinkedBlockin gDeque<Runnable>(3) =8个。如果超过8个,默认的拒绝策略会抛出异常
  • ②. CallerRunPolicy: 如果超过8个,不会抛出异常,会返回给调用者去
  • ③. DiscardOldestPolicy:如果超过8个,将最早进入队列的任务删除,之后再尝试加入队列 注意是删除队列，而非已在执行的任务
  • ④. DiscardPolicy:直接丢弃任务,不予任何处理也不抛出异常.如果允许任务丢失,这是最好的拒绝策略

合理配置线程池你是如何考虑的?

①. CPU密集型
在这里插入图片描述
②. IO密集型
在这里插入图片描述

Mr_tianyanxiaobai
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 线程池 优先队列_优先级线程池实现
weixin_39807859的博客
02-23 1271
运维在升级，无聊写博客最近在实现消息通知平台上面，对于针对不同的通知需要设置优先级，实现当通知队列堵塞的时候可以有限推送高优先级的消息。为了保证通知队列的高效并发，通知队列的消费端是采用多线程并发处理的，因此需要实现一个可以实现优先级的多线程处理逻辑：对于ThreadPollExecutor来说，public PriorityThreadPoolExecutor(int corePoolSize,...
并发——阻塞队列
youngpeople_的博客
11-14 1263
一.概述 1、介绍 　　强烈建议读者看这篇之前，先了解队列相关知识，以及生产者与消费者模式。 　　concurrent 包中，BlockingQueue 很好的解决了多线程中，如何高效安全"传输"数据的问题。通过这些高效并且线程安全的队列类，为快速搭建高质量的多线程程序带来极大的便利。 　　阻塞队列，首先它是一个队列（先进先出），通过一个共享的队列，可以使得数据从队列的一端输入，从另外一端输出。 当队列是空的，从队列中获取元素的操作将会被阻塞。 当队列是满的，从队列中添加元素的操作将会被阻塞。 2
Java多线程高并发学习笔记——阻塞队列
weixin_34186950的博客
10-31 131
在探讨可重入锁之后，接下来学习阻塞队列，这篇文章也是断断续续的写了很久，因为最近开始学ssm框架，准备做一个自己的小网站，后续可能更新自己写网站的技术分享。 请尊重作者劳动成果，转载请标明原文链接： http://www.cnblogs.com/superfj/p/7757876.html 阻塞队列是什么？ 首先了解队列，队列是数据先进先出的一种数据结构...
线程池设置原则
最新发布
Java小白的博客 致力分享每一天学到的知识
07-21 860
为了减少创建和销毁线程的次数，让每个线程都可以多次的使用，可以根据系统情况调整线程的数量，防止消耗过多内存。在实际使用中，服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当大，使用线程池就可以优化。在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。
高并发编程之阻塞队列
weixin_60257072的博客
12-14 534
Concurrent 包中，BlockingQueue 很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了 BlockingQueue 家庭中的所有成员，包括他们各自的功能以及常见使用场景。阻塞队列，顾名思义，首先它是一个队列, 通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出；当队列是空的，从队列中获取元素的操作将会被阻塞当队列是满的，从队列中添加元素的操作将会被阻塞。
JUC 之 线程阻塞工具 LockSupport
bad_boy的博客
02-25 392
每个线程对象中都有一个中断标识位，用于表示线程是否被中断；通过调用线程对象的 interrupt 方法将该线程的标识位设为 true，可以在别的线程中调用，也可以在自己的线程中调用。中断只是一种协作协商机制，Java 没有给中断增加任何语法，中断的过程完全需要程序员自己实现。若要中断一个线程，你需要手动调用该线程的 interrupt 方法，接着你需要自己写代码不断地检测当前线程的标识位，如果为 true，表示别的线程请求这条线程中断，此时该做什么需要你自己写代码实现。以上两个对象使用的限制条件。
JUC并发编程.rar
12-14
"JUC并发编程.rar"这个压缩包文件包含了关于并发编程的相关案例源码和详细讲解，旨在帮助初学者和经验丰富的开发者深入理解并发编程的核心概念和技术。 首先，让我们来看看并发编程的基本概念。并发是指在一段时间...
java并发编程：juc、aqs
08-09
Java并发编程中的`JUC`(Java Util Concurrency)库是Java平台中用于处理多线程问题的核心工具包，它提供了一系列高效、线程安全的工具类，帮助开发者编写并发应用程序。`AQS`(AbstractQueuedSynchronizer)是JUC库中的...
JUC并发编程学习笔记(硅谷)
07-23
Java并发编程是Java开发中的重要领域，特别是在大型分布式系统或者高并发应用中，对线程安全和性能优化的理解与实践至关重要。"JUC并发编程学习笔记(硅谷)"很可能包含了关于Java并发工具集（Java Util Concurrency, ...
JUC并发编程「公开课第三讲」.pdf
02-02
### JUC并发编程公开课第三讲知识点总结 #### 一、线程池基本概念与优势 1. **定义**: 线程池是一种管理线程执行任务的机制，它通过限制运行线程的数量来提高系统资源利用率。具体而言，线程池会将待处理的任务放...
面试必问并发编程高级面试专题.zip
06-30
并发编程是计算机科学中的一个重要领域，特别是在Java等多线程编程语言中，它涉及到如何在多个执行线程之间共享资源和协调任务。本面试专题主要针对高级并发编程的知识点进行探讨，旨在帮助求职者在面试中展现出深厚...
JVM优先级线程池做任务队列的实现方法
08-18
主要介绍了JVM优先级线程池做任务队列的实现方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
JUC高并发编程(14) -- 阻塞队列
姜皓的博客
05-12 175
阻塞队列
JUC - 基本线程阻塞原语LockSupport
李平安
04-26 788
一.概述 LockSupport 和 CAS 是Java并发包中很多并发工具控制机制的基础，它们底层其实都是依赖Unsafe实现。 LockSupport是创建锁和其他同步类的基本线程阻塞原语，park 和 unpark 方法提供了阻塞和解除阻塞线程的有效方法 LockSupport类以及每个使用它的线程和一个permit（{@link java.util.concurrent.Semaph...
高并发编程（阻塞队列，put,take源码， 线程池）
qq_35059264的博客
08-08 392
谁无风暴劲雨时，守得云开见月明 阻塞队列BlockingQueue 队列：先进先出数组。 既队列满了等待队列为空的时候进行写入，如果队列空了则等待队有数据后进行消费。 接口结构： 集合派生出List(可变数组)，Set(不可重复队列)，Queue(先进先出队列)，先进先出队列后派生除了BlockingQueue(阻塞队列)，Deque(链表双端队列)，abstractQueue（非阻塞队列），阻塞队列又派生出ArrayBlockingQueue（数组队列），LinkedBlockingQueue(链表数
Java多线程/并发26、阻塞队列BlockingQueue
程序老兵的博客
05-07 2990
BlockingQueue接口定义了一种队列，这种队列通常容量是提前固定（确定了容量大小）的。容量满时往BlockingQueue中添加数据时会造成阻塞，容量为空时取元素操作会阻塞。我们可以认为BlockingQueue队列是一个水库。水库满了的时侯，上游的水就要被拦住，不能再往水库里灌了。平时农庄浇灌，生活饮用都用这里面的水。如果水库干了，那么要灌溉的工人只能等着上游放水后，才能继续工作。 实际
Java高并发之阻塞队列（什么是阻塞队列、4对操作、7种阻塞队列、实现原理）
lucyLee的博客
10-06 3452
1. 阻塞队列概述 ① 什么是阻塞队列 阻塞队列（BlockingQueue）是一个支持两个附加操作的队列，这两个附加的操作支持阻塞的插入和移除方法。 支持阻塞的插入方法：当队列满时，队列会阻塞插入元素的线程，直到队列不满。 支持阻塞的移除方法：当队列为空时，获取元素的线程会等待队列变为非空。 阻塞队列常用于生产者和消费者场景，生产者是向队列里添加元素的线程，消费者是从队列里获取元素的线...
java 线程池 优先队列_深入学习java并发之线程池
weixin_28366475的博客
02-23 259
这篇文章将从以下几个方面讲述Excutor框架以及线程池：。。。。一、首先来看一下Executor框架的基本组成：1. Executor是一个基础的接口，设计它的目的就是将任务的提交与任务的执行解耦，所以这个接口里就只定义了一个方法：excute(Runaable command);源码：1 public interfaceExecutor {2 //任务3 /*@par...
java 线程池 优先队列_Java 优先队列 PriorityQueue PriorityBlockingQueue 源码分析
weixin_32272937的博客
02-23 224
基本使用@Testpublic void testPriorityQueue() throws InterruptedException {PriorityQueue priorityQueue = new PriorityQueue(Lists.newArrayList(5, 4, 2, 1, 3));System.out.println(priorityQueue);System.out.pr...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值