等待唤醒机制和阻塞队列

已于 2024-09-11 20:14:09 修改
阅读量205 收藏
点赞数 10
分类专栏： Java学习 文章标签： java 开发语言 多线程
于 2024-09-11 20:12:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2202_76097976/article/details/142148922
版权

在这里插入图片描述

 

1. 等待唤醒机制

由于线程的随机调度，可能会出现“线程饿死”的问题：也就是一个线程加锁执行，然后解锁，其他线程抢不到，一直是这个线程在重复操作

void wait()

当前线程等待，直到被其他线程唤醒

void notify()

随机唤醒单个线程

void notifyAll()

唤醒所有线程

等待（wait）：当一个线程执行到某个对象的wait()方法时，它会释放当前持有的锁（如果有的话），并进入等待状态。此时，线程不再参与CPU的调度，直到其他线程调用同一对象的notify()或notifyAll()方法将其唤醒，类似的，wait() 方法也可以传入一个参数表示等待的时间，不加参数就会一直等

唤醒（notify/notifyAll）:

notify: 唤醒在该对象监视器上等待的某个线程，如果有多个线程在等待，那么具体唤醒哪一个是随机的

notifyAll: 唤醒在该对象监视器上等待的所有线程

1.1. wait

上面的方法是Object提供的方法，所以任意的Object对象都可以调用，下面来演示一下：

public class ThreadDemo14 {
    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        System.out.println("wait前");
        obj.wait();
        System.out.println("wait后");
    }
}

结果抛出了一个异常：非法的锁状态异常，也就是调用wait的时候，当前锁的状态是非法的

这是因为，在wait方法中，会先解锁然后再等待，所以要使用wait，就要先加个锁，阻塞等待就是把自己的锁释放掉再等待，不然一直拿着锁等待，其他线程就没机会了

把wait操作写在synchronized方法里就可以了，运行之后main线程就一直等待中，在jconsole中看到的也是waiting的状态

注意：wait操作进行解锁和阻塞等待是同时执行的（打包原子），如果不是同时执行就可能刚解锁就被其他线程抢占了，然后进行了唤醒操作，这时原来的线程再去等待，已经错过了唤醒操作，就会一直等

wait执行的操作：1. 释放锁并进入阻塞等待，准备接收唤醒通知 2. 收到通知后唤醒，并重新尝试获得锁

1.2. notify

接下来再看一下notify方法：

public class ThreadDemo15 {
    private static Object lock = new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            synchronized (lock){
                System.out.println("t1 wait 前");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("t1 wait 后");
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (lock){
                System.out.println("t2 notify 前");
                Scanner sc = new Scanner(System.in);
                sc.next();//这里的输入主要是构造阻塞
                lock.notify();
                System.out.println("t2 notify 后");
            }
        });
    }
}

然后就会发现又出错了，还是之前的错误，notify也需要先加锁才可以

把之前的notify也加进synchornized就可以了，并且还需要确保是同一把锁

调用wait方法的线程会释放其持有的锁，被唤醒的线程在执行之前，必须重新获取被释放的锁

public class Cook extends Thread {
    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    if (Desk.foodFlag == 0) {
                        try {
                            Desk.lock.wait();//厨师等待
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        Desk.count--;
                        System.out.println("还能再吃" + Desk.count + "碗");
                        Desk.lock.notifyAll();//唤醒所有线程
                        Desk.foodFlag = 0;
                    }
                }
            }
        }
    }
}
public class Foodie extends Thread {
    @Override
    public void run() {
        while (true) {
            synchronized (Desk.lock) {
                if (Desk.count == 0) {
                    break;
                } else {
                    if (Desk.foodFlag == 1) {
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    } else {
                        System.out.println("已经做好了");
                        Desk.foodFlag = 1;
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}
public class Desk {
    public static int foodFlag = 0;

    public static int count = 10;
    //锁对象
    public static Object lock = new Object();
}

这里实现的功能就是，厨师做好食物放在桌子上，美食家开始品尝，如果桌子上没有食物，美食家就等待，有的话，厨师进行等待

sleep() 和 wait() 的区别：

这两个方法看起来都是让线程等待，但是是有本质区别的，使用wait的目的是为了提前唤醒，sleep就是固定时间的阻塞，不涉及唤醒，虽然之前说的Interrupt可以使sleep提前醒来，但是Interrupt是终止线程，并不是唤醒，wait必须和锁一起使用，wait会先释放锁再等待，sleep和锁无关，不加锁sleep可以正常使用，加上锁sleep不会释放锁，抱着锁一起睡，其他线程无法拿到锁

在刚开始提到过，如果有多个线程都在同一个对象上wait，那么唤醒哪一个线程是随机的：

public class ThreadDemo16 {
    private static Object lock = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("t1 wait 前");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("t1 wait 后");
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("t2 wait 前");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("t2 wait 后");
            }
        });
        Thread t3 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("t3 wait 前");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("t wait 后");
            }
        });
        Thread t4 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("t4 notify 前");
                Scanner sc = new Scanner(System.in);
                sc.next();
                lock.notify();
                System.out.println("t4 notify 后");
            }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

这次只是t1被唤醒了

还可以使用notifyAll，把全部的线程都唤醒

2. 阻塞队列

2.1. 阻塞队列的使用

阻塞队列是一种特殊的队列，相比于普通的队列，它支持两个额外的操作：当队列为空时，获取元素的操作会被阻塞，直到队列中有元素可用；当队列已满时，插入元素的操作会被阻塞，直到队列中有空间可以插入新元素。

当阻塞队列满的时候，线程就会进入阻塞状态：

public class ThreadDemo19 {
    public static void main(String[] args) throws InterruptedException {
        BlockingDeque<Integer> blockingDeque = new LinkedBlockingDeque<>(3);
        blockingDeque.put(1);
        System.out.println("添加成功");
        blockingDeque.put(2);
        System.out.println("添加成功");
        blockingDeque.put(3);
        System.out.println("添加成功");
        blockingDeque.put(4);
        System.out.println("添加成功");
    }
}

同时，当阻塞队列中没有元素时，再想要往外出队，线程也会进入阻塞状态

public class ThreadDemo20 {
    public static void main(String[] args) throws InterruptedException {
        BlockingDeque<Integer> blockingDeque = new LinkedBlockingDeque<>(20);
        blockingDeque.put(1);
        System.out.println("添加成功");
        blockingDeque.put(2);
        System.out.println("添加成功");
        blockingDeque.take();
        System.out.println("take成功");
        blockingDeque.take();
        System.out.println("take成功");
        blockingDeque.take();
        System.out.println("take成功");
    }
}

2.2. 实现阻塞队列

根据阻塞队列的特性，可以尝试来自己手动实现一下

可以采用数组来模拟实现：

public class MyBlockingDeque {
    private String[] data = null;
    private int head = 0;
    private int tail = 0;
    private int size = 0;

    public MyBlockingDeque(int capacity) {
        data = new String[capacity];
    }
}

接下来是入队列的操作：

public void put(String s) throws InterruptedException {
    synchronized (this) {
        while (size == data.length) {
            this.wait();
        }
        data[tail] = s;
        tail++;
        if (tail >= data.length) {
            tail = 0;
        }
        size++;
        this.notify();
    }
}

由于设计到变量的修改，所以要加上锁，这里调用wait和notify来模拟阻塞场景，并且需要注意wait要使用while循环，如果说被Interrupted打断了，那么就会出现不可预料的错误

出队列也是相同的道理：

public String take() throws InterruptedException {
String ret = "";
synchronized (this) {
    while (size == 0) {
        this.wait();
    }
    ret = data[head];
    head++;
    if (head >= data.length) {
        head = 0;
    }
    size--;
    this.notify();
}
return ret;
}

3. 生产者消费者模型

生产者消费者模型是一种经典的多线程同步模型，用于解决生产者和消费者之间的协作问题。在这个模型中，生产者负责生产数据并将其放入缓冲区，消费者负责从缓冲区中取出数据并进行处理。生产者和消费者之间通过缓冲区进行通信，彼此之间不需要直接交互。这样可以降低生产者和消费者之间的耦合度，提高系统的可维护性和可扩展性。

而阻塞队列可以当做上面的缓冲区：

public class ThreadDemo21 {
    public static void main(String[] args) {
        BlockingDeque<Integer> blockingDeque = new LinkedBlockingDeque<>(100);
        Thread t1 = new Thread(()->{
            int i = 1;
            while (true){
                try {
                    blockingDeque.put(i);
                    System.out.println("生产元素：" + i);
                    i++;
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t2 = new Thread(()->{
            while (true){
                try {
                    int i = blockingDeque.take();
                    System.out.println("消费元素：" + i);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        t2.start();
    }
}

如果说把sleep的操作放到线程2会怎么样？

线程一瞬间就把阻塞队列沾满了，后面还是一个线程生产，一个线程消费，虽然打印出来的有偏差

生产者和消费者之间通过缓冲区进行通信，彼此之间不需要直接交互。这样可以降低生产者和消费者之间的耦合度，提高系统的可维护性和可扩展性。 

在这里插入图片描述

 

2的n次方_
关注
  • 10
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程：阻塞队列与等待唤醒机制初探
流楚丶格念的博客
07-16 2056
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。...
阻塞队列实现等待唤醒机制
TTYYNX的博客。
02-10 507
public class Cooker extends Thread { private ArrayBlockingQueue<String> bd; public Cooker(ArrayBlockingQueue<String> bd) { this.bd = bd; } // 生产者步骤： // 1，判断桌子上是否有汉堡包 // 如果有就等待，如果没有才生产。 // 2，把汉堡.
【Java】阻塞队列实现等待唤醒机制
qq_39921135的博客
07-15 756
底层是链表实现的，无界（指没有长度的界限），创建它的对象的时候我们不需要去指定队列的长度。但是它又并不是真正的无界，它其实也是有最大值的，只不过这个最大值非常的大，是int的最大值，有21个亿那么多。但是写在锁的外面并不会对数据的安全造成影响，它没有对共享数据造成任何的修改/改编，它只是对我们看运行的结果造成了一点点不方便而已。并且take()的底层也是有锁的，我们在写代码的时候也不需要去加锁了，否则就会有锁的嵌套，锁的嵌套容易导致死锁。程序运行完毕，发现结果怎么跟想象的不太一样，这里怎么会有连续的？
多线程（Lock锁，死锁，等待唤醒机制，阻塞队列，线程池）
m0_46702681的博客
06-20 1080
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,时间的单位，任务队列,创建线程工厂,任务的拒绝策略);参数一:核心线程数量 不能小于θ参数二:最大线程数 不能小于等于0，最大数量 >= 核心线程数量参数三:空闲线程最大存活时间 不能小于θ参数四:时间单位 用TimeUnit指定。
多线程学习-等待唤醒机制
qq_65568592的博客
04-07 787
等待唤醒机制即通过wait和notify实现多线程之间的通信，进而实现多线程协同工作。
【Java】阻塞队列 BlcokingQueue 原理、与等待唤醒机制condition/await/singal的关系、多线程安全总结
qq_44577070的博客
03-05 1072
在实习过程中使用阻塞队列对while + sleep 轮询机制进行了改造，提升了发送接收的效率，这里做一点点总结。 自从Java 1.5之后，在java.util.concurrent包下提供了若干个阻塞队列，BlcokingQueue继承了Queue接口，是线程安全的。阻塞功能使得生产者和消费者两端的能力得以平衡，当阻塞队列是空时，从队列中获取元素的操作将会被阻塞。当阻塞队列是满时，往队列里添加元素的操作将会被阻塞。
线程间等待与唤醒机制、单例模式、阻塞队列、定时器
XHT117的博客
06-26 1188
目录线程间等待与唤醒机制线程等待wait唤醒方法notify面试题：wait方法和sleep方法的区别练习单例模式 饿汉式单例懒汉式单例解决懒汉式的线程安全问题阻塞式队列JDK中的阻塞队列BlockingQueue定时器——类比现实生活中的闹钟......
【并发】阻塞队列与等待队列
m0_62645012的博客
01-15 809
在多线程编程中，等待队列和阻塞队列是两个重要而常用的概念。在本文中，我们将深入探讨等待队列和阻塞队列的概念、特点以及它们在多线程环境下的应用。
JAVA-多线程等待唤醒机制-阻塞队列
m0_68711597的博客
08-28 78
可以实现等待唤醒常规的等待唤醒机制就是加了锁以及在适当位置增加wait（等待） notify(唤醒) 或是用sleep(计算时间等待)用阻塞队列更加方便但是需要注意的是生产者和消费者必须使用同一个队列 否则存放和 拿到的数据不是同一个 再创建一个类 foodie 大概内容与cook相似 创建测试类 最后可以看到代码跑起来了
Java多线程03——等待唤醒机制(and阻塞队列实现)
qq_59708493的博客
01-23 733
桌子上有食物，消费者吃，桌子上没有食物，消费者等待，唤醒生产者，生产者准备食物。生产者准备好食物，唤醒消费者，消费者开吃。没有运行状态，运行状态是Java运行start()就绪状态后交给操作系统的。是否有面条 foodFlag=0：没有。foodFlag=1：有。作用：控制生产者和消费者的执行。
剖析Java中阻塞队列的实现原理及应用场景
09-03
阻塞队列和非阻塞队列的主要区别在于处理满队列和空队列的情况。非阻塞队列如`LinkedList`和`PriorityQueue`在队列满或空时，会立即返回结果，而阻塞队列则会阻塞等待直到条件满足。 对于非阻塞队列，常用的方法如`...
Java中的阻塞队列详细介绍
09-01
阻塞队列的实现依赖于底层的锁机制，如`ReentrantLock`，以及条件变量，如`Condition`，来确保线程安全和阻塞/唤醒机制。 例如，ArrayBlockingQueue的公平访问可以通过构造函数的布尔参数控制，如`new ...
91- 等待唤醒机制（阻塞队列）
记录java学习日常~
09-18 171
阻塞是指线程在某些条件下被暂停执行，进入等待状态，直到满足特定条件才能继续执行的一种机制。在多线程编程中，当一个线程需要访问共享资源或等待某个事件发生时，可能会发生阻塞。线程可以通过调用阻塞方法来实现阻塞，例如等待锁、等待某个条件满足、等待输入输出等。在阻塞的过程中，线程会暂停执行，不占用CPU资源，并且会释放掉它占有的某些资源（如锁），以便其他线程可以获取这些资源并继续执行。当满足特定条件时，线程将被唤醒，重新获得资源，并继续执行。阻塞可以用于实现线程间的同步和协作。
spring事务详细讲解-深入浅出
小电玩
09-08 424
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1424
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1355
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 354
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 497
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
自定义Stater
m0_63624484的博客
09-07 694
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值