6_尚硅谷面试 第二季 -阻塞队列

最新推荐文章于 2024-08-07 22:59:42 发布
最新推荐文章于 2024-08-07 22:59:42 发布
阅读量100 收藏
点赞数
分类专栏： 面试 文章标签： 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45757978/article/details/123669471
版权
阻塞队列理论
ArrayBlockingQueue ：是一个基于数组结构的有界阻塞队列，此队列按FIFO(先进先出) 原则对元素进行排序
LinkedBlockingQueue： 一个基于链表结构的阻塞队列，此队列按照FIFO(先进先出)排序元素，吞吐量通常高于ArrayBlockingQueue 
synchronousQueue： 一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量要高于ArrayBlockingQueue
阻塞队列
当阻塞队列是空时，从队列中获取元素的操作将会阻塞
当阻塞队列是满时，往队列里添加元素的操作将会阻塞
试图从空的阻塞队列中获取元素将会被阻塞，直到其他线程往空的队列中插入新的元素
试图往已满的阻塞队列中添加新元素将会被阻塞，直到其他线程从队列中移除一个或多个元素或者清空队列使队列重新变的空闲起来并后续新增
阻塞队列 好处
在多线程领域：所谓阻塞，在某些情况下会挂起线程，一旦条件满足，被挂起的线程又会自动被唤醒
好处是：我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为这一切BlockingQueue都给你一手包办
在concurrent发布之前，在多线程环境下，我们需要自己去控制这些细节，尤其还要兼顾线程安全和效率，增加复杂度
阻塞队列种类分析
**ArrayBlockingQueue: 由数组构成的有界阻塞队列**
**LinkedBlockingQueue：由链表结构组成的有界(默认值为Integer.MAX_VALUE)**
PriorityBlockingQueue: 支持优先级排序的无界阻塞队列
DelayQueue： 使用优先级队列实现的延迟无界阻塞队列
**SynchronousQueue: 不存储元素的阻塞队列，也即单个元素的队列**
LinkedTransferQueue： 由链表结构组成的无界阻塞队列
LinkedBlockingDeque：由链表结构组成的双向阻塞队列
BlockingQueue
抛异常
    public static void main(String[] args) {
        BlockingQueue<String> deque = new ArrayBlockingQueue<String>(3);
        deque.add("a");
        deque.add("b");
        deque.add("c");
        //deque.add("d"); //Exception in thread "main" java.lang.IllegalStateException: Queue full
        deque.remove("a"); //移除 A 元素
        System.out.println(deque.element()); // a 已经 被 移除 所以输出b 
        deque.remove();
        deque.remove();
        deque.remove();//Exception in thread "main" java.util.NoSuchElementException
        deque.remove();
    }

	当阻塞队列满时，再往队列里add插入元素会抛出异常
	当阻塞队列空时，再往队列里remove移除元素抛出异常
特殊值
  public static void main(String[] args) {
        BlockingQueue<String> deque = new ArrayBlockingQueue<String>(3);
        System.out.println(deque.offer("a")); //ture
        System.out.println(deque.offer("b")); //ture
        System.out.println(deque.offer("c")); //ture
        System.out.println(deque.offer("d")); //false
        System.out.println(deque.peek()); // a
        System.out.println(deque.poll()); // a
        System.out.println(deque.poll()); // b
        System.out.println(deque.poll()); // c
        System.out.println(deque.poll()); //  null 没有返回 null
    }

插入方法，成功TRUE 失败 FALSE
移除方法，成功返回队列中的元素 ，没有返回null
一直阻塞
public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> deque = new ArrayBlockingQueue<String>(3);
        deque.put("a");
        deque.put("b");
        deque.put("c");
        deque.put("d"); // 队列满了 阻塞等待
        deque.take();
        deque.take();
        deque.take();
        deque.take(); // 队列空了 阻塞
    }

当阻塞队列满时，生产者线程继续往队列里PUT元素，队列会一直阻塞生产线程直到PUT数据or响应中断退出
当阻塞队列空时，消费者线程试图从队列里take元素，队列会一直阻塞消费者线程直到队列可用
超时退出
public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> deque = new ArrayBlockingQueue<String>(3);
        System.out.println(deque.offer("a", 2L, TimeUnit.SECONDS));
        System.out.println(deque.offer("b", 2L, TimeUnit.SECONDS));
        System.out.println(deque.offer("c", 2L, TimeUnit.SECONDS));
        System.out.println(deque.offer("d", 2L, TimeUnit.SECONDS));//超时 将返回FALSE

        System.out.println(deque.poll(2L, TimeUnit.SECONDS));
        System.out.println(deque.poll(2L, TimeUnit.SECONDS));
        System.out.println(deque.poll(2L, TimeUnit.SECONDS));
        System.out.println(deque.poll(2L, TimeUnit.SECONDS)); //没有 将返回FALSE
    }

当阻塞队列满时，队列会阻塞生产者线程一定时间，超时后限时候生产者线程会退出
SynchronousQueue
SynchronousQueue没有容量
与其他BlockingQUeue不同，SynchronousQueue是一个不存储元素的BlockingQUeue
每一个put操作必须等待一个take操作，否则不能继续添加元素，反之亦然

 public static void main(String[] args) {

        BlockingQueue queue = new SynchronousQueue();


        new Thread(() -> {

            try {
                System.out.println(Thread.currentThread().getName() + " \t " + "1");
                queue.put("1");
                System.out.println(Thread.currentThread().getName() + " \t " + "2");
                queue.put("2");
                System.out.println(Thread.currentThread().getName() + " \t " + "3");
                queue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }).start();


        new Thread(() -> {

            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + " \t " + "1");
                queue.take();
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + " \t " + "2");
                queue.take();
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + " \t " + "3");
                queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }).start();

    }
生产者消费者
lock
多个条件
/**
 * A 打印 5 次
 * B 打印 10 次
 * C 打印 15 次
 * 接着又是 A
 */
public class TestManyCondition {

    public static void main(String[] args) {

        Resouce resouce = new Resouce();
        new Thread(() -> {
            try {
                resouce.print5();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                resouce.print10();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                resouce.print15();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();


    }

}

class Resouce {
    ReentrantLock lock = new ReentrantLock();
    private volatile int num = 1;
    Condition a = lock.newCondition();
    Condition b = lock.newCondition();
    Condition c = lock.newCondition();


    public void print5() throws InterruptedException {

        lock.lock();
        try {
            while (num != 1) {
                a.await();
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("A");
            }
            num = 2;
            b.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }

    public void print10() throws InterruptedException {

        lock.lock();
        try {
            while (num != 2) {
                b.await();

            }
            for (int i = 0; i < 10; i++) {
                System.out.println("B");
            }
            num = 3;
            c.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }

    public void print15() throws InterruptedException {
        lock.lock();
        try {
            while (num != 3) {
                c.await();
            }
            for (int i = 0; i < 15; i++) {
                System.out.println("C");
            }
            num = 1;
            a.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }


    }


}
虚假唤醒
public class TestProdConsumer_lock {

    public static void main(String[] args) {

        Mydata2 mydata = new Mydata2();


        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                mydata.incr();
            }
        },"AA").start();


        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                mydata.decr();
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                mydata.incr();
            }
        },"CC").start();


        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                mydata.decr();
            }
        },"DD").start();




    }
}

class Mydata2{

    private Lock lock = new ReentrantLock();
    private  Condition condition = lock.newCondition();
    private volatile  int num = 0;

    public void incr(){
        lock.lock();
        try{
            if (num != 0 ){ // 等待
                condition.await();
            }

            //干活
            num++;
            System.out.println(Thread.currentThread().getName() + "  " + num);
            condition.signalAll();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public void decr(){
        lock.lock();
        try{
            if (num == 0 ){ // 等待
                condition.await();
            }

            //干活
            num--;
            System.out.println(Thread.currentThread().getName() + "  " + num);
            condition.signalAll();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

}

/**

AA  1
BB  0
CC  1
AA  2
DD  1
DD  0
BB  -1
BB  -2
BB  -3
BB  -4
CC  -3
AA  -2
DD  -3
DD  -4
DD  -5
CC  -4
AA  -3
CC  -2
AA  -1
CC  0

Process finished with exit code 0

*/

解决
将if换成while

public class TestProdConsumer_lock {

    public static void main(String[] args) {

        Mydata2 mydata = new Mydata2();


        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                mydata.incr();
            }
        },"AA").start();


        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                mydata.decr();
            }
        },"BB").start();

        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                mydata.incr();
            }
        },"CC").start();


        new Thread(()->{
            for (int i = 0; i < 5; i++) {
                mydata.decr();
            }
        },"DD").start();




    }
}

class Mydata2{

    private Lock lock = new ReentrantLock();
    private  Condition condition = lock.newCondition();
    private volatile  int num = 0;

    public void incr(){
        lock.lock();
        try{
            while (num != 0 ){ // 等待
                condition.await();
            }

            //干活
            num++;
            System.out.println(Thread.currentThread().getName() + "  " + num);
            condition.signalAll();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public void decr(){
        lock.lock();
        try{
            while (num == 0 ){ // 等待
                condition.await();
            }

            //干活
            num--;
            System.out.println(Thread.currentThread().getName() + "  " + num);
            condition.signalAll();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

}
队列版本
public class TestProdConsumer_Queue {

    public static void main(String[] args) throws InterruptedException {
        MySources sources = new MySources(new ArrayBlockingQueue<String>(10));
        new Thread(()->{
            try {
                sources.prod();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"p").start();
        new Thread(()->{
            try {
                sources.consu();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"C").start();

        TimeUnit.SECONDS.sleep(5);

        sources.stop();

    }
}

class MySources {

    private BlockingQueue<String> blockingQueue = null;

    private volatile Boolean flag = true;

    private AtomicInteger integer = new AtomicInteger(0);

    public MySources(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    public void prod() throws InterruptedException {
        String data = "";
        while (flag) {
            TimeUnit.SECONDS.sleep(1);
            data = integer.incrementAndGet() + "";
            boolean offer = blockingQueue.offer(data, 2, TimeUnit.SECONDS);
            if (offer) {
                System.out.println(Thread.currentThread().getName() + "\t 放入成功" + " \t " + data);
            } else {
                System.out.println(Thread.currentThread().getName() + "\t 放入失败");
            }
        }
        System.out.println("停止生产");
    }

    public void consu() throws InterruptedException {
        while (flag) {
            TimeUnit.SECONDS.sleep(1);
            String result = blockingQueue.poll(2, TimeUnit.SECONDS);
            if (result == null || result.equalsIgnoreCase("")) {
                System.out.println(Thread.currentThread().getName() + "\t 获取失败");
            } else {
                System.out.println(Thread.currentThread().getName() + "\t 获取成功" + " \t " + result);

            }
        }
        System.out.println("不让消费");
    }

    public void stop(){
        flag = false;
    }
}
Synchronized 和 lock区别
1、原始构成
	synchronized是关键字 属于JVM层面
		monitorenter（底层通过monitor对象来完，其实wait/notify等方法也依赖与monitor对象只有在同步块或者方法中才能调用wait/notify）
		monitorexit (两个 防止异常死锁)
	Lock是具体类，是api层面的锁
2、使用方法
		synchronized 不需要用户手动释放锁，当synchronized代码执行完成系统会自动让线程释放锁的占用
		ReentranLock 则需要用户手动去释放锁，若没有手动释放锁，则可能导致死锁
		需要lock() 和 unlock() 方法配合try/finally语句完成
3、等待是否可中断
	synchronized 不可中断，除非抛出异常或者正常运行完成
	ReentranLock  可中断，1.设置超时方法，tryLock(long,timeout,TimeUnit unit)
										  2.lockInterruptibly() 放在代码块中，调用interrupt()方法可以中断
4、加锁是否公平
	synchronized  非公平锁
	ReentranLock  都可以 默认非公平 构造方法可以传入 bool值 TRUE 为公平 FALSE 为非公平锁
5、锁绑定多个条件Condition
	synchronized   没有
	ReentranLock   用来实现分组唤醒需要唤醒的线程，可以精确唤醒，而不是像synchronized   随机唤醒一个线程要么唤醒全部线程
qq_45757978
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
定时发送消息--延迟队列
mawenqi0729的博客
06-23 1824
定时发送消息–延迟队列 一、定时器（Timer） 定时计划任务功能在Java中主要使用的就是Timer对象，它在内部使用多线程的方式进行处理，所以它和多线程技术还是有非常大的关联的。在JDK中Timer类主要负责计划任务的功能，也就是在指定的时间开始执行某一个任务，用TimerTask类封装任务。 通过Timer和Timetask，我们可以实现定时启动某个线程。 java.util.Timer 在这种实现方式中，Timer类作用是类似闹钟的功能，也就是定时或者每隔一定时间触发一次线程。其实，Timer类
阻塞队列
爱笑的boy的博客
04-02 316
阻塞队列
《尚硅谷高级技术之JUC高并发编程》09——阻塞队列
weixin_43301424的博客
12-05 165
文章目录01 BlockingQueue 简介02 BlockingQueue 核心方法BlockingQueue 的核心方法03 常见的 BlockingQueueArrayBlockingQueue( 常用)LinkedBlockingQueue(常用)DelayQueuePriorityBlockingQueueSynchronousQueueLinkedTransferQueueLinkedBlockingDeque总结 高并发编程学习笔记，学习资源 ——《尚硅谷高级技术之 JUC 高并发编程》。
7_尚硅谷面试 第二季 -线程池
qq_45757978的博客
03-25 2384
callable 接口 public class TestCallable { public static void main(String[] args) throws ExecutionException, InterruptedException { FutureTask<Integer> task = new FutureTask<>(new MyCallable()); FutureTask<Integer> task1
尚硅谷大厂面试题第三季周阳主讲
06-24
【标题】"尚硅谷大厂面试题第三季周阳主讲"主要涵盖了Java后端面试中的核心知识点，包括Java并发编程（JUC）、Redis缓存系统以及Spring框架的应用。本内容整理了B站尚硅谷频道关于大厂面试的全部资料，帮助考生全面...
2019互联网面试题第2季.mmap
10-09
上半场，从多线程并发入手，分层递进讲解，逐步让大家掌握volatile、原子类和原子引用、CAS、ABA、Java锁机制、阻塞队列、线程池等重点；下半场，逐步过渡到JVM和GC的知识 ，深度讲解多种常见OOM异常和JVM参数调优，...
2019年_BATJ大厂面试题总结-字节跳动篇
12-22
如果二次哈希后还是哈希冲突呢？ 答案：https://blog.csdn.net/u012712901/article/details/78313130?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task 2.integer...
尚硅谷_互联网大厂高频重点面试题（第2季）.xmind
07-05
尚硅谷_互联网大厂高频重点面试题（第2季） 自己手动整理，额外赠送源代码，略有改动哈哈。 斩offer、拿高薪、跳槽神器，对标阿里P6的《尚硅谷_互联网大厂高频重点面试题（第2季）》发布。 知其然，更要知其所以然...
尚硅谷面试题第三季1
08-03
【标题】：“尚硅谷面试题第三季1” 【描述】：本题目涉及的是Java基础，特别是关于字符串常量池的使用和理解，以及在JDK7及后续版本中的变化。在Java14环境下，测试结果显示两个使用`intern()`方法的比较都返回了`...
15：00面试，15：08就出来了，问的问题有点变态。。。
2301_78276982的博客
08-05 6690
整份文档一共有将近 200 页，全部为大家展示出来肯定是不太现实的，为了不影响大家的阅读体验就只展示了部分内容，还望大家海涵，希望能帮助到您面试前的复习且找到一个好的工作，也节省大家在网上搜索资料的时间来学习！
程序员找工作之数据结构面试题总结分析
学无止境，止于至善
08-02 530
栈简述什么是栈？栈的内存是怎么分配的？栈溢出的原因以及解决方法？栈的两个应用：括号匹配是怎么应用的？简述栈和队列的区别？链表简述什么是链表？简述链表的分类？链表与数组的区别？链表类型有哪些？如何使用队列实现堆栈？队列简述什么是队列？简述队列的使用场景？树简述什么是二叉树？简述什么是满二叉树？简述什么是完全二叉树？简述什么是平衡二叉树（AVL Tree）？简述什么是排序二叉树？简述什么是红黑树？简述什么是B-TREE？
Android应用开发面试之Jetpack面试题分析汇总
学无止境，止于至善
08-02 910
Jetpack简介请简述一下Jetpack是什么，以及它在Android开发中的作用。Jetpack相比传统Android SDK有哪些主要优势？Jetpack核心组件你能列举并解释Jetpack中的一些核心组件（如LiveData, ViewModel, Room, Navigation等）吗？这些组件是如何帮助开发者实现MVC、MVP或MVVM等架构模式的？
前端面试：项目细节重难点问题分享（十五）
weixin_49062485的博客
08-02 543
更多详情：爱米的前端小笔记（csdn~xitujuejin~zhiHu~Baidu~小红shu）同步更新，等你来看！都是利用下班时间整理的，整理不易，大家多多👍💛➕🤔哦！你们的支持才是我不断更新的动力！对了，给大家悄悄送个小福利哦：前后端/测试岗内（https://jinshuju.net/f/o38ijj）感兴趣可④我 ”！啦啦啦啦啦✧٩(ˊωˋ*)و✧！
力扣面试150 基本计算器 双栈模拟
最新发布
人言束负
08-07 116
满注释版
redis面试（六）分布式锁开篇
weixin_41011482的博客
08-06 360
为什么要使用分布式锁，zk和reids都是怎么实现分布式锁的
力扣216题详解：组合总和 III 的多种解法与模拟面试
10年数据\经营分析经验，现任大厂数据分析负责人
08-03 81
本文详细解读了力扣第216题“组合总和 III”，通过使用回溯法和迭代法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
“八股文“在现代编程面试中的角色重塑：助力、阻力还是桥梁？
Zwq的博客
08-02 1364
在科技日新月异的今天，编程已成为推动社会进步的重要力量。而在程序员招聘的舞台上，“八股文”——即一系列标准化、模式化的面试问题和技术知识点，成为了不可或缺的一环。它如同一把双刃剑，既为招聘者提供了快速筛选候选人的工具，也让部分程序员对其产生了“形式主义”的质疑。本文旨在深入探讨“八股文”在程序员面试及日常工作中的实际作用，并提出改进其学习和评估方法的建议。
Spring面试资料大全
Hello World
08-02 484
Spring是一个轻量级Java开发框架，最早有创建，目的是为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。它是一个分层的JavaSE/JavaEE full-stack（一站式）轻量级开源框架，为开发Java应用程序提供全面的基础架构支持。Spring负责基础架构，因此Java开发者可以专注于应用程序的开发。Spring最根本的使命是解决企业级应用开发的复杂性，即简化Java开发。Spring可以做很多事情，它为企业级开发提供给了丰富的功能，但是这些功能的底层都依赖于它的两个核心特性，也就是。
"Java NIO_尚硅谷课件V1.01：阻塞IO与FileChannel详解
第二章介绍了Java NIO的Channel，包括FileChannel、ServerSocketChannel、SocketChannel和DatagramChannel。其中，FileChannel是一种用于文件读写操作的通道，课件通过介绍和示例详细说明了FileChannel的操作以及其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值