JAVA并发编程（三）-wait-notify

最新推荐文章于 2024-02-08 09:55:29 发布
最新推荐文章于 2024-02-08 09:55:29 发布
阅读量675 收藏 30
点赞数 30
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_36531037/article/details/135942796
版权

文章目录

一、 🧡简介

  在Java中，wait() 和 notify() 方法是Object类的一部分，用于线程间的通信和同步。这些方法通常用于一种情况，即一个线程需要等待某个条件满足才能继续执行，而另一个线程需要在条件满足时发出通知。
在这里插入图片描述

API接口：
wait() 方法：用于使一个线程等待，直到另一个线程为相同的对象调用 notify() 或 notifyAll() 方法。

notify() 方法“：唤醒当前正在等待该对象的某个线程。唤醒哪个线程不是确定的，取决于JVM的实现。

notifyAll() 方法：唤醒所有当前正在等待该对象的线程。

它们都属于Object对象的方法，必须获得到此对象的锁，才能够调用者几个方法。

二、💛api演示

（1）wait()和notify()

public class TestWaitNotify {

    final static Object object = new Object();

    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            synchronized (object) {
                log.debug("执行代码");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                log.debug("其他代码");
            }
        },"t1").start();

        new Thread(() -> {
            synchronized (object) {
                log.debug("执行代码");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                log.debug("其他代码");
            }
        },"t2").start();


        //睡眠两秒
        TimeUnit.SECONDS.sleep(2);

        synchronized (object){

            log.debug("唤醒其中一个线程");
            object.notify();
        }
        
    }
}

执行结果：
在这里插入图片描述
我们可以看到这里notify（）这个方法，只唤醒了t1的线程。

（2）wait()和notifyAll()

@Slf4j(topic = "TestWaitNotify")
public class TestWaitNotify {

    final static Object object = new Object();

    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            synchronized (object) {
                log.debug("执行代码");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                log.debug("其他代码");
            }
        },"t1").start();

        new Thread(() -> {
            synchronized (object) {
                log.debug("执行代码");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                log.debug("其他代码");
            }
        },"t2").start();


        //睡眠两秒
        TimeUnit.SECONDS.sleep(2);

        synchronized (object){

            log.debug("唤醒其中一个线程");
            object.notifyAll();
        }

    }
}

在这里插入图片描述
我们可以看到这里notifyAll把t1和t2线程都唤醒了。

（3）wait(long timeout)

new Thread(() -> {
    synchronized (object) {
        log.debug("执行代码");
        try {
            object.wait(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        log.debug("其他代码");
    }
},"t1").start();

执行结果：
在这里插入图片描述
我们可以看到这里我们设置了wait的入参是1000ms，当到了1000ms之后，这里就不会再等待下去了，而是直接唤醒当前线程，继续执行后面的代码。
注意：无参的wait（）会一直等待直到有notify或notifyAll（）进行唤醒

💚三、sleep和wait的区别

（1）sleep是Thread方法，而wait是Object方法。
（2）sleep不需要强制和synchronized配合使用，但wait需要和synchronized一起用。
（3）sleep在睡眠的同时，不会释放对象锁，但wait在等待的时候会释放对象锁。

接下来我们来分析一下以下代码

@Slf4j(topic = "TestCorrectPostureStep1")
public class TestCorrectPostureStep1 {

    static final Object room = new Object();

    static  boolean hasCigaratte = false;


    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigaratte);


                while (!hasCigaratte) {
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }

                log.debug("有烟没？[{}]", hasCigaratte);

                if (hasCigaratte) {
                    log.debug("开始干活");
                }

            }
        }, "小南").start();


        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                synchronized (room){
                    log.debug("开始干活");
                }
            },"其他人"+i).start();
        }


       TimeUnit.SECONDS.sleep(1);
        new Thread(()->{
            hasCigaratte=true;
            log.debug("来送烟喽");
        },"送烟的").start();


    }
}

执行结果：
在这里插入图片描述
我们可以看到这里当小南没有烟的时候，依然占用着房间的使用权，只有等到送烟的人到了，小南才去干活，而小南干完活以后，让出了房间的使用权，才能够让其他人去干活。
那这里就存在一个问题，当小南占用着房间的时候，其他人没法干活

我们可以改成使用wait（）notify（）来改良这段代码。

@Slf4j(topic = "TestCorrectPostureStep1")
public class TestCorrectPostureStep1 {

    static final Object room = new Object();

    static boolean hasCigaratte = false;


    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigaratte);


                while (!hasCigaratte) {
                    try {
                        room.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }

                log.debug("有烟没？[{}]", hasCigaratte);

                if (hasCigaratte) {
                    log.debug("开始干活");
                }

            }
        }, "小南").start();


        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                synchronized (room) {
                    log.debug("开始干活");
                }
            }, "其他人" + i).start();
        }


        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            synchronized (room) {
                hasCigaratte = true;
                room.notify();
                log.debug("来送烟喽");
            }
        }, "送烟的").start();


    }
}

执行结果：
在这里插入图片描述
我们可以看到这里当小南没有烟的时候，小南线程进入了等待的队列，同时释放了room的控制权，让其他线程可以进房间内干活，直到送烟的线程唤醒小南线程才拿回room控制权开始干活。

💙四、notify（）和notifyAll（）虚假唤醒

观察一下以下代码

@Slf4j(topic = "TestCorrectPostureStep1")
public class TestCorrectPostureStep1 {

    static final Object room = new Object();

    static boolean hasCigaratte = false;

    static boolean hasTakeOut = false;


    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            synchronized (room) {
                log.debug("有烟没？[{}]", hasCigaratte);


                    try {
                        room.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }


                log.debug("有烟没？[{}]", hasCigaratte);

                if (hasCigaratte) {
                    log.debug("开始干活");
                }else{
                    log.debug("没干成活");
                }

            }
        }, "小南").start();


        new Thread(() -> {
            synchronized (room) {
                log.debug("有外卖没？[{}]", hasTakeOut);


                    try {
                        room.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }


                log.debug("有外卖没？[{}]", hasTakeOut);

                if (hasTakeOut) {
                    log.debug("开始吃饭");
                }else{
                    log.debug("没吃上饭 ");
                }

            }
        }, "小女").start();


        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            synchronized (room) {
                hasTakeOut = true;
                room.notify();
                log.debug("来送外卖喽");
            }
        }, "送外卖喽").start();


    }
}

执行结果：
在这里插入图片描述
我们可以看到当送外卖来了的时候，进行了notify，但是并没有唤醒小女，而是唤醒了小南，小南醒来后发现并没有烟，所以干不成活，那么遇到这种情况该怎么办呢？细心的同学可以发现这里我只要改动成notifyAll（）把小南小女都唤醒了，这样就可以了。

room.notifyAll();

执行结果：
在这里插入图片描述
如果我们想小南没烟来，也继续歇着，我们可以这样写

while(!hasCigaratte){
    log.debug("没有烟，先歇着");
    try {
        room.wait();
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
}

在这里插入图片描述

💜五、设计模式-保护性暂停

（1）定义

  即Guarded Suspension，用在一个线程等待另一个线程的执行结果。
要点
1、有一个结果需要从一个线程传递到另一个线程，让他们关联同一个GuardedObject。
2、如果 有结果不断从一个线程到另一个线程那么就可以使用消息队列（生产者/消费者）
3、JDK中，join的实现，Future的实现，就是采用这种模式。
4、因为要等待另一方的记过，因此归类到同步模式。
在这里插入图片描述

（2）编写代码

那我们就来编写一下代码吧。

@Slf4j(topic = "TestProtectivePause")
public class TestProtectivePause {

    public static void main(String[] args) {
        Guared guared = new Guared();

        new Thread(() -> {
            //等待结果
            log.debug("等待结果");
            Object o = guared.get();
            log.debug(o.toString());
        }, "t1").start();


        new Thread(() -> {

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            guared.complete("结果数据");
        }, "t2").start();


    }


}


class Guared {
    private Object response;
	//获取结果
    public Object get() {
        synchronized (this) {
            //没有结果
            while (response == null) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return response;
    }


    //产生结果
    public void complete(Object response) {
        synchronized (this) {
            this.response = response;
            this.notifyAll();
        }
    }

}

执行结果：
在这里插入图片描述

（3）增加超时效果

@Slf4j(topic = "TestProtectivePause")
public class TestProtectivePause {

    public static void main(String[] args) {
        Guared guared = new Guared();

        new Thread(() -> {
            //等待结果
            log.debug("等待结果");
            Object o = guared.get(1000);
            log.debug("结果是{}",o);
        }, "t1").start();


        new Thread(() -> {

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            guared.complete("结果数据");
        }, "t2").start();


    }


}


class Guared {
    private Object response;

    //获取结果
    //timeout表示要等待多久
    public Object get(long timeout) {
        synchronized (this) {

            //开始时间
            long begin = System.currentTimeMillis();
            //经历的时间
            long passed = 0;

            //没有结果
            while (response == null) {
                //如果经历的时间大于超时时间,则直接退出
                if (passed >= timeout) {
                    break;
                }
                try {
                    //这里等待的时间应为超时时间减去已经经历的时间，因为会存在虚假唤醒的情况
                    //当线程在超时前唤醒，但response依然为null，会进入下次循环，下次循环的时候等待时间不应该为超时等待的时间，应为超时时间减去已经历的时间
                    this.wait(timeout - passed);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                //经历时间应为当前时间减去开始的时间
                passed = System.currentTimeMillis() - begin;
            }
        }
        return response;
    }


    //产生结果
    public void complete(Object response) {
        synchronized (this) {
            this.response = response;
            this.notifyAll();
        }
    }

}

执行结果：
在这里插入图片描述

🤎六、生产者/消费者模式

（1）定义

1、与前面的保护性暂停中的GuardObject不同，不需要产生结果和消费结果的线程一一对应。
2、消费队列可以用来平衡生产和消费的线程资源。
3、生产者仅负责产生结果数据，不关心数据如何处理，而消费者专心处理结果数据。
4、消息队列是有容量限制的，满时不会再加入数据，空时不会消耗数据。
5、JDK中各种阻塞队列，采用的就是这种模式。
在这里插入图片描述

（2）编写代码

 @Slf4j(topic = "TestMessageQueue")
public class TestMessageQueue {


    public static void main(String[] args) {


        MessageQueue queue = new MessageQueue(2);

        for (int i = 0; i < 3; i++) {


            int id=i;
            new Thread(() -> {
                queue.put(new Message(id, "值" + id));
            }, "生产者" + i).start();


        }

        new Thread(() -> {
        }, "消费者").start();
    }

}

@Slf4j(topic = "MessageQueue")
class MessageQueue {


    //消息的队列集合
    private LinkedList<Message> list = new LinkedList<>();


    //队列容量
    private int capcity;


    public MessageQueue(int capcity) {
        this.capcity = capcity;
    }

    //获取消息
    public Message take() {
        synchronized (list) {
            while (list.isEmpty()) {
               log.debug("队列为空，消费者线程等待");
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            //从队列头部获取消息并返回
            Message message = list.removeFirst();
            list.notifyAll();
            return message;
        }
    }

    //存入消息
    public void put(Message message) {
        synchronized (list) {
            while (list.size() == capcity) {
                log.debug("队列已满，生产者线程等待");
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            list.addLast(message);
            log.debug("已生产消息");
            list.notifyAll();
        }
    }

}


@Getter
@AllArgsConstructor
@ToString
final class Message {


    private int id;

    private Object value;


}

执行结果
在这里插入图片描述
这里当生产者生产出三个，而容量为2的时候，消费者并没有消费行为，会导致第三个生产者无法进行生产。

接下来我们来修改一下消费者的代码。

  new Thread(() -> {

            while(true){
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                queue.take();
            }
        }, "消费者").start();

执行结果：
在这里插入图片描述

imperfectsam
关注
java——wait和notify的基本用法
xhhhx_的博客
04-14 1万+
wait的用法以及它的3种结束条件：1.notify2.interrupted3.时间超时
【Java多线程编程】wait与notify方法详解
我的主页
05-18 3673
本期讲解：Java 多线程中的 wait方法、notify方法、notifyAll方法，wait方法与sleep方法之间的区别。
【Java|多线程与高并发】wait和notify方法详解
云泽野の编程日记
06-22 1552
在Java多线程环境中,线程之间是抢占式执行的,线程的调度是随机的.这就很难受了. 在很多情况下我们希望线程以我们想要的顺序来执行. 这就需要wait和notify这两个方法wait和notify方法用于实现线程间的协作和通信.wait方法使线程进入等待状态，notify方法唤醒一个等待线程，notifyAll方法唤醒所有等待线程。通过上述三个方法，可以使线程按照特定的顺序执行或者等待某个条件满足后再执行。希望这篇文章能帮到你!专栏:《从零开始的Java学习之旅》在不断更新中,欢迎订阅!
一文秒懂 Java wait() 和 notify() 方法
最新发布
smart_an的专栏
02-08 1288
大家有没有发现，其实 「 一文秒懂 」 系列讲述的都是多线程并发开发的问题。这个话题太大了，估计没有上百篇文章都解释不清楚。本文，我们来讲解下 Java 并发中的基础的基础，核心的核心，Java 并发编程中的最基本的机制之一 - 「 线程同步 」为了方便你理解并发编程中的各种概念和术语，我们首先会来一阵扫盲，讨论一些基本的并发相关术语和方法。接着，我们将开发一个简单的应用程序，并在合格应用程序里处理并发问题，以方便大家理解和巩固wait()和notify()。
java并发编程 4：线程的暂停唤醒 wait/notify与park/unpark
qq_43745578的博客
06-29 992
使用wait/notify与park/unpark实现线程的暂停和唤醒，即一些涉及的模式实现
详解Java程序并发的Wait-Notify机制
09-03
Java程序并发的Wait-Notify机制是Java多线程编程中的一种重要同步工具，它允许线程之间通过共享对象进行通信和协作。这个机制基于Java的内置锁（也称为监视器锁），通常与`synchronized`关键字一起使用。在Java中，`...
java并发编程实战源码-concurrent-programming:《Java并发编程实战》源码整理
05-25
《Java并发编程实战》这本书是Java并发编程领域的一本经典之作，它深入浅出地讲解了如何在Java环境中高效、安全地进行多线程编程。源码整理集合`concurrent-programming-master`提供了书中示例代码，对于学习和理解...
Java 并发编程实战-随书源码
04-27
《Java并发编程实战》这本书是Java开发者深入理解并发编程的重要参考书籍。本书旨在帮助程序员解决在多线程环境中遇到的实际问题，提升系统性能并保证其稳定性。随书源码提供了丰富的示例，让读者能够动手实践，加深...
[原]Java并发编程实践-读书笔记
10-13
《Java并发编程实践》这本书是Java开发者深入理解并发编程的重要参考。以下是对书中关键知识点的总结： 1. **线程和进程的区别** - **线程**：是程序执行的最小单位，一个进程中可以有多个线程，它们共享同一块...
JAVA并发编程实践-中文-高清-带书签-完整版
11-04
《JAVA并发编程实践》是Java开发人员深入理解并发编程的一本经典著作，由Doug Lea撰写，本书中文版高清完整，包含丰富的书签，便于读者查阅和学习。这本书旨在帮助开发者掌握在Java平台上进行高效、安全并发编程的...
Java中的wait和notify方法
m0_67683346的博客
09-15 1852
java中的wait和notify方法
深入理解Java中的wait() 方法
热门推荐
小楼夜听雨的博客
05-20 3万+
使用场景 当某个线程获取到锁后，发现当前还不满足执行的条件，就可以调用对象锁的wait方法，进入等待状态。 直到某个时刻，外在条件满足了，就可以由其他线程通过调用notify()或者notifyAll()方法，来唤醒此线程。 这篇文章将侧重于讨论wait()方法对于线程状态的影响，以及被唤醒后线程的状态变更。 条件 只有已经获取锁的线程，才可以调用锁的wait方法，否则会抛出异常IllegalMonitorStateException。 比如下面的代码，A获得了锁后，主动调用wait方法释放锁和
java的wait_java wait()方法用法详解
weixin_29426299的博客
02-12 1万+
一、wait(), notify(), notifyAll()等方法介绍1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线...
Java多线程基础-7：wait() 和 notify() 用法解析
wyd_333的博客
04-26 7565
详解Java多线程编程中，wait()和notify()方法的使用方式和注意事项，配合代码案例~
Java线程基础(13):wait()和notify()
mingyuli的博客
07-21 1万+
简介 本文讲解Java中wait()、notify()，通过一个标准的使用实例，来讨论下这两个方法的作用和使用时注意点，这两个方法被提取到顶级父类Object对象中，地位等同于toString()方法。 一、wait()和notify()含义 wait()方法是让当前线程等待的，即让线程释放了对共享对象的锁，不再继续向下执行。 wait(long timeout)方法可以指定一个超时时间，过了这个时间如果没有被notify()唤醒，则函数还是会返回。如果传递一个负数timeout会抛出I...
Java多线程中的 wait() 和 notify() 方法
sinat_31583645的博客
03-17 2922
多线程并发的场景下，有时需要某些线程先执行，这些线程执行结束后其他线程再继续执行, wait()和notify()是Object类的方法，用于线程的等待与唤醒，必须搭配synchronized 锁来使用。
[Java 多线程技术]（七）使用wait/notify实现线程间通信
YHJ
06-10 2134
线程是操作系统中独立的个体，但这些个体如果不经过特殊处理就不能成为一个整体。线程间的通信就是成为整体的必用方案之一，可以说，使线程间进行通信后，系统之间的交互性会更加强大，在大大提高CPU利用率的同时还会使程序员对各线程任务在处理的过程中进行有效的把控和监督。 1. 等待通知机制 1.1 不使用等待/通知机制实现线程间通信 　　创建新项目，在实验中使用sleep()结合while(true)死循环法来实现多个线程间通信。代码如下： public class MyList { priva.
java中的wait和notify方法
qq_37753562的博客
01-08 4192
/* 守护线程 */ // 启动线程之前，将线程设置为守护线程 t.setDaemon(true); // 即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程自动终止。 1.4、关于object类中的wait和notify方法。（生产者和消费者模式！) 第一：wait和notify方法不是线程对象的方法，是java中任何一个java对象都有的方法，因为这两个方式是Object类中自带的。 wait方法和notify方法不是通过线程对象调用， ...
Java中wait和notify方法的详解
zl5186888的博客
09-20 1073
最开始是线程A获取了对象的锁，然后调用了对象的wait()方法后，从而释放了锁，并且让线程A进入了对象的等待队列中，进入了Waiting状态。此时由于线程A释放了对象的锁，线程B就有机会随后获取到了对象的锁，并且调用了notify()方法，此时线程A接到了通知，随后就从对象的等待队列进入了同步队列(SynchronizedQueue)，此时线程A从Waiting状态进入了Blocked状态，如果线程B又释放完对象的锁后，线程A有机会获取到对象的锁，就会从wait()方法返回继续执行后续的操作。
《Java并发编程艺术》- 深入解析与实战指南
"本书是《Java并发编程的艺术》，由方腾飞、魏鹏程和晓明合著，主要探讨Java平台上的并发编程技术。书中深入解析了Java并发框架和线程池的实现，旨在帮助读者理解并发编程的核心原理，并提供实战技巧和解决并发问题...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值