多线程之生产者与消费者模型、wait()、notify()和notifyAll()

最新推荐文章于 2020-11-27 11:01:33 发布
最新推荐文章于 2020-11-27 11:01:33 发布
阅读量367 收藏
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smell201611010513/article/details/90349081
版权

一、wait()与notify()

1.wait()-痴汉方法

前面介绍的join()对wait()进行了包装
wait()就是使线程停止运行，会释放对象锁。

特点：
1）wait()会使当前线程调用该方法后进行等待，并且将该线程置入锁对象的等待队列，直到接到通知或被中断为止。
2）wait()只能在同步方法或同步代码块中调用，如果调用wait()时没有适当的锁，会抛出异常。
3）wait()执行后，当前线程释放锁，其它线程可以竞争该锁。

wait()会使线程从运行态到阻塞态。何时回到运行态？调用notify()

wait()之后的线程继续执行有两种方法：
1）调用该对象的notify()唤醒该线程
2）线程等待时调用interrupt()中断该线程

wait(long time);如果到了预计时间还未被唤醒，线程将继续执行。time单位：毫秒

package com.xunpu.b;

class MyThread implements Runnable{
    private Object object=new Object();
    @Override
    public void run() {
        synchronized (object){
            System.out.println("wait()开始");
            try {
//                object.wait();//会一直死等
               object.wait(1000);//只等待1秒，1秒后继续执行。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("wait()结束");
        }
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread=new MyThread();
        Thread thread=new Thread(myThread);
        thread.start();
//        Thread.sleep(2000);
//        thread.interrupt();
    }
}

2.notify()

特点：
1）notify()也必须在同步方法或同步代码块中调用，用来唤醒等待在该对象上的线程。如果有多个线程等待，则任意挑选一个线程唤醒。
2）notify()执行后，唤醒线程不会立即释放对象锁，要等待唤醒线程全部执行完毕后才释放对象锁。

注意：notify()和wait()只有执行同一个对象时，才会释放资源。

package com.xunpu.b;

class MyThread implements Runnable{
    //锁定对象
    private Object object=new Object();
    private boolean flag;//设置标志来决定走哪个方法

    public MyThread(Object object, boolean flag) {
        this.object = object;
        this.flag = flag;
    }
    public void waitMethod(){
        synchronized (object){
            System.out.println("wait()开始"+Thread.currentThread().getName());
            try {
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("wait()结束"+Thread.currentThread().getName());
        }
    }

    public void notifyMethod(){
        synchronized (object){
            System.out.println("notify()开始。。。"+Thread.currentThread().getName());
            object.notify();
            System.out.println("notify()结束。。。"+Thread.currentThread().getName());
        }
    }
    @Override
    public void run() {
        if(flag==true){
            waitMethod();
        }else {
            notifyMethod();
        }
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Object object=new Object();//这个对象必须为两个线程所共有
        MyThread myThread1=new MyThread(object,true);
        MyThread myThread2=new MyThread(object,false);//同一个对象，才可以释放。
        Thread waitThread=new Thread(myThread1,"等待线程");
        Thread notifyThread=new Thread(myThread2,"唤醒线程");
        waitThread.start();//先启动等待线程！！
        Thread.sleep(1000);//保证等待线程先启动！！
        notifyThread.start();

    }
}

3.notifyAll()

唤醒所有在该对象上等待的线程。

package com.xunpu.b;

class MyThread implements Runnable{
    //锁定对象
    private Object object=new Object();
    private boolean flag;//设置标志来决定走哪个方法

    public MyThread(Object object, boolean flag) {
        this.object = object;
        this.flag = flag;
    }
    public void waitMethod(){
        synchronized (object){
            System.out.println("wait()开始"+Thread.currentThread().getName());
            try {
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("wait()结束"+Thread.currentThread().getName());
        }
    }

    public void notifyMethod(){
        synchronized (object){
            System.out.println("notify()开始。。。"+Thread.currentThread().getName());
            object.notifyAll();
            System.out.println("notify()结束。。。"+Thread.currentThread().getName());
        }
    }
    @Override
    public void run() {
        if(flag==true){
            waitMethod();
        }else {
            notifyMethod();
        }
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Object object=new Object();//这个对象必须为两个线程所共有
        MyThread myThread1=new MyThread(object,true);
        MyThread myThread2=new MyThread(object,false);//同一个对象，才可以释放。
        for(int i=0;i<10;i++){
            Thread threadi=new Thread(myThread1,"waitthread"+i);
            threadi.start();
        }
        Thread waitThread=new Thread(myThread1,"等待线程");
        Thread notifyThread=new Thread(myThread2,"唤醒线程");
        waitThread.start();//先启动等待线程！！
        Thread.sleep(1000);//保证等待线程先启动！！
        notifyThread.start();

    }
}

4.线程阻塞的五种情形

1）调用sleep()，主动放弃占有的CPU，不会释放对象锁。
2）调用阻塞式IO方法（read()、write())，在该方法返回前，线程阻塞。
3）线程试图获取一个monitor，但该monitor被其它线程所持有，导致阻塞。
4）线程等待某个通知，即调用wait()，释放对象锁。
5）调用suspend()，将线程挂起，容易导致死锁，已被废弃。

5.monitor的两个队列

每个monitor都有两个队列，一个称为同步队列，一个称为等待队列。
同步队列中都存放了因为竞争monitor失败导致阻塞的线程，这些线程等待CPU调度再次竞争锁。
等待队列存放因为调用wait()导致线程等待的线程，唤醒后进入同步队列竞争锁。

同步队列：所有获取Monitor失败的线程进入同步队列，等待获取锁。

等待队列：调用了wait()阻塞的线程进入等待队列。

二、生产消费者模型

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

package com.xunpu.b;

/**
 * 单线程版本的生产者-消费者模型
 */
class Goods{
    private String goodsName;
    private int count;

    @Override
    public String toString() {
        return "Goods{" +
                "goodsName='" + goodsName + '\'' +
                ", count=" + count +
                '}';
    }

    //生产商品方法
    public synchronized void set(String goodsName){
        if(count>0){
            System.out.println("商品还有库存，等会再生产！");
            try {
                wait();//等待消费者消费
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.goodsName=goodsName;
        this.count++;
        System.out.println(Thread.currentThread().getName()+"生产"+goodsName+toString());
        notify();//唤醒等待消费的线程
    }

    //消费商品方法
    public synchronized void get(){
        if(count==0){
            System.out.println("商品卖完了，请您等会。。。");
            try {
                wait();//等待商品生产
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.count--;
        System.out.println(Thread.currentThread().getName()+"消费"+goodsName+toString());
        notify();//唤醒生产者继续生产线程
    }
}
//消费者线程
class Consumer implements Runnable {
    private Goods goods;

    public Consumer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        goods.get();//消费
    }
}
//生产者线程
class Producer implements Runnable{
    private Goods goods;

    public Producer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        goods.set("炒米饭");//生产
    }
}
public class Test {
    public static void main(String[] args) throws InterruptedException {
      Goods goods=new Goods();//传递同一个商品。
      Thread produceThread=new Thread(new Producer(goods),"生产者线程");
      Thread consumerThread=new Thread(new Consumer(goods),"消费者线程");
      consumerThread.start();
      Thread.sleep(1000);
      produceThread.start();
    }
}

import java.util.ArrayList;
import java.util.List;

/**
 * 多线程版本的生产者-消费者模型
 */
class Goods{
    private String goodsName;
    private int count;

    public int getCount() {
        return count;
    }

    @Override
    public String toString() {

        return "Goods{" +
                "goodsName='" + goodsName + '\'' +
                ", count=" + count +
                '}';
    }

    //生产商品方法
    public synchronized void set(String goodsName){
//        //不断判断条件
//        while(count>0){
//            System.out.println("商品还有库存，等会再生产！");
//            try {
//                wait();//等待消费者消费
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }
        try {
            Thread.sleep(20);//每秒生产一个商品
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.goodsName=goodsName;
        this.count++;
        System.out.println(Thread.currentThread().getName()+"生产"+goodsName+toString());
        notifyAll();//唤醒等待消费的线程
    }

    //消费商品方法
    public synchronized void get(){
        //为什么是while?  如果消费者1来消费，此时没有库存，然后回唤醒生产者生产商品，生产一个刚好被消费。在生产的时候，消费者2
        //也来消费，此时可能会出现count<0的情况，一个商品被消费了多次。
        //不断判断执行条件
        while(count==0){
            System.out.println("商品卖完了，请您等会。。。");
            try {
                wait();//等待商品生产
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.count--;
        System.out.println(Thread.currentThread().getName()+"消费"+goodsName+toString());
        notifyAll();//唤醒生产者继续生产线程
    }
}
//消费者线程
class Consumer implements Runnable {
    private Goods goods;

    public Consumer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
        //不断消费商品
        while(true){
            goods.get();//消费
        }
    }
}
//生产者线程
class Producer implements Runnable{
    private Goods goods;

    public Producer(Goods goods) {
        this.goods = goods;
    }

    @Override
    public void run() {
//        //不断生产商品
//        while(true){
//            goods.set("炒米饭");//生产
//        }
        while(this.goods.getCount()<200){
            this.goods.set("炒米饭");
        }
    }
}
public class Test2 {
    public static void main(String[] args) {
        Goods goods=new Goods();
        //存储多个生产-消费者线程
        List<Thread> list=new ArrayList<Thread>();
        //10个消费者线程
        for(int i=0;i<10;i++){
            Thread thread=new Thread(new Consumer(goods),"消费者"+i);
            list.add(thread);
        }
        //5个生产者线程
        for(int i=0;i<5;i++){
            Thread thread=new Thread(new Producer(goods),"生产者"+i);
            list.add(thread);
        }

        for(Thread thread:list){
            thread.start();
        }
    }
}

三、wait()、notify()、notifyAll()的练习

package com.xunpu.c;

/**
 * 线程练习题1：写两个线程，一个线程打印1~52,另一个线程打印A~Z。
 * 打印顺序是12A34B.....5152Z
 * 思路：
 * 观察，每打印两个数字，就打印一个字母；打印完字母后立即打印数字，重复循环，直到打印完。
 * 线程间通信：信号量
 * 设置信号量控制打印字母还是数字
 */
class Print{
    int flag=1;
    int count=1;
    char c='A';
    public synchronized void printNum(){
        while(flag!=1){
            //此时应该打印字母
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print(2*count-1);
        System.out.print(2*count);
        flag=2;
        notify();
    }
    //打印字母
    public synchronized void printChar(){
        while(flag!=2){
            //打印数字
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print((char)(count-1+'A'));
        //继续前行
        count++;
        flag=1;
        notify();
    }
}
public class Demo1 {
    public static void main(String[] args) {
        final Print print=new Print();
//        while(print.count!=27) {
//            print.printNum();
//            print.printChar();
//        }
        new Thread(()->{
            for(int i=0;i<26;i++){
                print.printNum();
            }
        }).start();

        new Thread(()->{
            for(int i=0;i<26;i++){
                print.printChar();
            }
        }).start();
    }
}

package com.xunpu.c;

/**
 * 编写一个程序，启动三个线程，三个线程的名称分别是A,B,C；每个线程将自己的名称在屏幕上打印5遍。
 * 打印顺序是ABCABCABC......
 */
class MyPrint{
    int flag=1;
    static int count=0;//控制打印次数
    public synchronized void printA()  {
        while(flag!=1){
            //此时说明正在打印其它线程，等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print(Thread.currentThread().getName());
        count++;
        flag=2;//告诉B该B打印了。
        notifyAll();//防止notify()任意一个线程，将printC()唤醒，不能打印B，避免死锁。
    }
    public synchronized void printB(){
        while (flag!=2){
            //说明此时正在打印其它线程，等待。
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print(Thread.currentThread().getName());
        count++;
        flag=3;//告诉C，该C打印了。
        notifyAll();
    }
    public synchronized void printC(){
        while(flag!=3){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.print(Thread.currentThread().getName());
        count++;
        flag=1;
        notifyAll();
    }
}

class MyThread implements Runnable{
    MyPrint myPrint=new MyPrint();

    public MyThread(MyPrint myPrint) {
        this.myPrint = myPrint;
    }

    @Override
    public void run() {
        while(myPrint.count<16) {
            if (Thread.currentThread().getName().equals("A")) {
                myPrint.printA();
            } else if (Thread.currentThread().getName().equals("B")) {
                myPrint.printB();
            } else {
                myPrint.printC();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyPrint myPrint=new MyPrint();
        MyThread myThread=new MyThread(myPrint);
        Thread thread1=new Thread(myThread,"A");
        Thread thread2=new Thread(myThread,"B");
        Thread thread3=new Thread(myThread,"C");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

 

寻瀑
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java—多线程的通信、生产者与消费者模式
12-21
理解Java多线程通信和生产者-消费者模式对于编写高效并发程序至关重要。使用`synchronized`关键字和`wait()`, `notify()`, `notifyAll()`来控制线程间的协作，可以避免数据竞争和死锁等问题。同时，掌握线程的状态和...
如何在Java中正确使用 wait, notify 和 notifyAll
12-22
wait， notify 和 notifyAll，这些在多线程中被经常用到的保留关键字，在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。 　在 Java 中可以用 wait、notify 和 notifyAll 来实现...
线程同步、死锁与生产者消费者
12-05 833
一、问题引出 多个线程访问同一个资源时，如果操作不当就很容易产生意想不到的错误，比如常见的抢票程序： public class Demo1 { public static void main(String[] args) { Ticket tt = new Ticket(); new Thread(tt, "甲").start(); new ...
多线程之生产者与消费者模型
Rookie
06-17 1456
在这个模型中我们需要有三个主要类，分别是商品类，生产者类以及消费者类。 其中运行机制和我们平时的生产者与消费者的关系机制大同小异。 在这个模型中，我们需要定义一个容器来实现消费者与生产者之间的解耦，为了更贴近实际，采用FIFO原则的队列作为容器为最佳选择，并且此模型还遵循着以下两条规则： 1.当生产者生产商品数量超过容器限制时，停止生产； 2.当消费者消费商品导致容器为空时，停止消费。 以下通过两...
wait()、notify/notifyAll()的理解和生产者消费者举例
学而不思则忘
11-27 200
wait()、notify/notifyAll()方法是Object的本地final方法，无法被重写。 wait()使当前线程阻塞，前提是必须先获得锁，一般配合synchronized 关键字使用。即，一般在synchronized 同步代码块里使用 wait()、notify/notifyAll()方法。 由于 wait()、notify/notifyAll()在synchronized 代码块执行，说明当前线程一定是获取了锁的。 当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待.
wait()和notifyAll()使用---生产者和消费者模型
weixin_43946462的博客
06-01 201
锁池和等待池 锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。 等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对象的等待池中 notify和notifyAll的区别   如果线程调用了对象的 wait(
java多线程同步(wait、notify)生产者消费者简单示例
Dawish的专栏
07-16 2298
一、为何写最为一个Android开发者，如果做得不够深入可能为不会去处理多线程同步的问题，稍微简单点可能使用一个线程池就可以搞定了，有关线程池的介绍可以参考我的另一篇文章：ExecutorService+LruCache+DiskLruCache用一个类打造简单的图片加载库 只是前段时间研究Android音视频硬解码，看到开源项目中用到了线程同步，就是在视频的YUV数据的暂存，和解码为视频并展示，
浅谈java线程中生产者与消费者的问题
09-02
Java线程中的生产者与消费者问题是多线程编程中一个经典的设计模式，它涉及到线程间的同步和通信。这个问题的核心是解决如何在一个有限容量的仓库（通常称为缓冲区）中，使得生产者线程和消费者线程能有效地协同工作...
Java多线程中wait、notify、notifyAll使用详解
08-26
例如，在生产者-消费者模型中，生产者线程可以使用wait()方法等待消费者线程的唤醒，而消费者线程可以使用notify()或notifyAll()方法唤醒生产者线程。 wait、notify、notifyAll方法是Java多线程编程中非常重要的...
【并发编程】 — 线程间的通信wait、notify、notifyAll
12-21
三个线程顺序打印问题2.1.1 题目2.1.2 题目分析2.1.3 我的答案2.2 生产者消费者问题2.2.1 题目2.2.2 题目分析2.2.3 我的答案 源码地址：https://github.com/nieandsun/concurrent-study.git 1 wait、notify、...
内存泄露什么情况下会oom
qq1019486728的专栏
03-17 890
如下图，如果下图中 的Dalvik Heap行 Heap Size 13172大于apk给的内存，那么他就会出现oom，内存爆掉。
用wait和notify/notifyAll实现生产者消费者模式
Just Do IT
03-31 1611
生产者消费者模式的实现方式有很多种，比如采用Condition条件变量或者利用阻塞队列来进行实现。本文将采用Object中自带的wait和notify/notifyAll方法来实现这个模式。实现代码如下： import java.util.LinkedList; public class ProducerConsumerPattern{ public static final int MA
红黑树
热门推荐
找不到工作的程序员的博客
08-10 4万+
一、在理解红黑树之前，先看一些二叉查找树 二叉查找树特性：左字数上所有的节点的值都小于或等于他的根节点上的值                              右子树上所有节点的值均大于或等于他的根节点的值                              左、右子树也跟别为平衡二叉树       举个二叉树的例子：                    可以看到如果要...
Java多线程问题--wait/notifyAll多生产者和多消费者
樊先知樊先知的博客
01-02 387
本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！ 代码地址：https://github.com/xianzhixianzhixian/thread.git 相关知识讲解 1、wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，知道接到通知或被中断位置。在wait()方法调用前，线程必须获得该对象的对象级...
如何在 Java 中正确使用 wait, notify 和 notifyAll
极北三少
08-05 2725
wait, notify 和 notifyAll，这些在多线程中被经常用到的保留关键字，在实际开发的时候很多时候却并没有被大家重视。本文对这些关键字的使用进行了描述。 在 Java 中可以用 wait、notify 和 notifyAll 来实现线程间的通信。。举个例子，如果你的Java程序中有两个线程——即生产者和消费者，那么生产者可以通知消费者，让消费者开始消耗数据，因为队列缓冲区中有内
多线程中wait(),notify()和notifyall()方法的含义
qiuwenjie123的博客
03-12 3177
在“synchronized(obj){··········}”这个同步块中，obj对象叫做监控器，只有持有监控器这个对象的锁时才会执行同步块中的内容Java中的线程的生命周期大体可分为5种状态。1. 新建(NEW)：新创建了一个线程对象。2. 可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选...
高并发编程：9、wait、notify、notifyAll（三 完整的消费者、生产者）
oJueQiang123456的博客
08-01 123
一、概述 上一篇文章介绍到多个生产者和多个消费者时，会使生产者和消费者都处于wait等待状态，处于假死状态。 所以用notifyAll替换notify，唤醒所有处于等待中的线程。 二、代码 public class Thread12 { private Integer index = 0; private volatile boolean isProducer = fa...
八大排序算法总结与Java实现
11-03 3183
原文：https://itimetraveler.github.io/2017/07/18/%E5%85%AB%E5%A4%A7%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95%E6%80%BB%E7%BB%93%E4%B8%8Ejava%E5%AE%9E%E7%8E%B0/ 概述 因为健忘，加上对各种排序算法理解不深刻，过段时间面对排序就蒙了。
黑马程序员——多个生产者，多个消费者 notifyAll()
知识搬运工，资料任你拿，包括书籍、电影、电视剧、网站、软件等，VX公人人人号：向前书局
08-26 453
----------------------    android培训    java培训   期待与您交流！    ----------------------                           package thread; /**  * 多个生产者，多个消费者  * @author zjw  *  */ public class Procedure_C
Java多线程-生产者与消费者问题
最新发布
02-03
总结，解决Java多线程中的生产者与消费者问题，关键在于理解线程同步和通信机制，如何利用`wait()`和`notify()`来确保并发操作的正确性和顺序。在实际编程中，合理设计类结构，利用同步代码块或synchronized方法来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值