wait()、notify()和notityALL()

最新推荐文章于 2024-04-24 10:00:00 发布
最新推荐文章于 2024-04-24 10:00:00 发布
阅读量506 收藏
点赞数 1

wait()、notify()和notityALL()

wait方法是Object中的方法，这个方法的功能特性：
1).执行wait方法的前提是当前线程已经获取到对象的锁，也就是wait方法必须在synchronized修饰的代码块或者方法中使用。 
2).执行wait之后，当前线程会失去锁的所有权，并暂停执行，一直等待，直到其他线程调用notify()、notifyAll()把其唤醒或者所在线程被中断
3).被notify()或者notifyAll()唤醒后，wait线程并不会立即开始继续执行，wait线程还是会等待，直到拥有锁的所有权，才会继续往下执行。

notify、notifyAll
notify已经在上面有提到过，notify和notifyAll 的作用是唤醒正在wait的线程，notify是**随机唤醒**wait线程中的一个，notifyAll 则是唤醒全部。
1).执行notify、notifyAll 方法的前提是当前线程已经获取到对象的锁，也就是必须在synchronized修饰的代码块或者方法中使用。这个和wait是一样的。 
2).之前wait的线程被notify()或者notifyAll()唤醒后，wait线程还是会继续等待，直到拥有锁的所有权，wait线程才会继续往下执行。 
3).调用notify、notifyAll不会释放锁，而是等待代码块执行完之后才释放锁，这个与wait不同。

如下几个例子来说明他们的使用：
例子一：
public static void main(String[] args) throws InterruptedException {
        Object lock1 = new Object();
        Thread t1 = new Thread(new Test().new Tt1(lock1));
        Thread t2 = new Thread(new Test().new Tt2(lock1));
        t1.start();
        Thread.sleep(1000);
        t2.start();
    }


    class Tt1 implements Runnable{

        private Object lock1;

        public Tt1(Object lock1) {
            this.lock1 = lock1;
        }

        @Override
        public void run() {
            try {
                System.out.println(this.getClass()+"-------1");
                synchronized (lock1) {
                    Thread.sleep(2000);
                    System.out.println("waiting start");
                    lock1.wait();
                }
                System.out.println("waiting end");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    class Tt2 implements Runnable{

        private Object lock1;

        public Tt2(Object lock1) {
            this.lock1 = lock1;
        }

        @Override
        public void run() {
            System.out.println(this.getClass()+"-------1");
            synchronized (lock1) {
                try {
                    System.out.println(this.getClass()+"-------2");
                    lock1.notify();
                    Thread.sleep(1000);
                    System.out.println(this.getClass()+"-------3");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }
执行结果：

class Test$Tt1-------1
class Test$Tt2-------1
waiting start
class Test$Tt2-------2
class Test$Tt2-------3
waiting end

分析一下： 
第1、2行：t1和t2启动，t1先获取到锁所以t1先执行，t2一直被阻塞住 
第3、4行：t1中执行了wait，所以锁被释放，t1暂停执行，处于等待状态，t2获取锁并开始执行。 
第5、6行：t2中调用了notify()唤醒t1，但是t2并不会释放锁所以t1没有马上执行，因为锁现在是被t2拥有，等t2执行完成释放锁后，t1继续执行。


例子二：
public static void main(String[] args) throws InterruptedException {
        Object lock1 = new Object();
        Thread t1 = new Thread(new Test().new Tt1(lock1));
        Thread t2 = new Thread(new Test().new Tt2(lock1));
        t1.start();
        Thread.sleep(100);
        t2.start();
    }

    class Tt1 implements Runnable{
        private Object lock1;

        public Tt1(Object lock1) {
            this.lock1 = lock1;
        }

        @Override
        public void run() {
            try {
                synchronized (lock1) {
                    System.out.println(Thread.currentThread().getName()+"---start");
                    lock1.wait();
                    Thread.sleep(3000);
                    System.out.println(Thread.currentThread().getName()+"---end");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    class Tt2 implements Runnable{

        private Object lock1;

        public Tt2(Object lock1) {
            this.lock1 = lock1;
        }

        @Override
        public void run() {
            synchronized (lock1) {
                try {
                    System.out.println(Thread.currentThread().getName()+"---start");
                    System.out.println(Thread.currentThread().getName()+"---end");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }
运行结果：
Thread-0---start
Thread-1---start
Thread-1---end
Thread-0执行wait后马上释放了锁，所以Thread-1很快接着就执行，但是Thread-0没有被唤醒，所以Thread-0就终止运行了。


例子三：
public static void main(String[] args) throws InterruptedException {
        Object lock1 = new Object();
        Thread t1 = new Thread(new Test().new Tt1(lock1));
        Thread t2 = new Thread(new Test().new Tt2(lock1));
        t1.start();
        Thread.sleep(100);
        t2.start();
    }

    class Tt1 implements Runnable{
        private Object lock1;

        public Tt1(Object lock1) {
            this.lock1 = lock1;
        }

        @Override
        public void run() {
            try {
                synchronized (lock1) {
                    System.out.println(Thread.currentThread().getName()+"---start");
                    lock1.notify();
                    Thread.sleep(3000);
                    System.out.println(Thread.currentThread().getName()+"---end");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    class Tt2 implements Runnable{

        private Object lock1;

        public Tt2(Object lock1) {
            this.lock1 = lock1;
        }

        @Override
        public void run() {
            synchronized (lock1) {
                try {
                    System.out.println(Thread.currentThread().getName()+"---start");
                    System.out.println(Thread.currentThread().getName()+"---end");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }
--------------------- 
执行结果：

Thread-0---start
Thread-0---end
Thread-1---start
Thread-1---end

可见Thread-0在执行nofity后并没有释放锁，而是等待代码块执行完之后才释放锁，Thread-1才能继续执行。

例子四：
wait()遇到interrupt()
之前说道interrupt()，并不会直接中断线程，而是会给线程一个中断标志，而且包括sleep、wait、join会抛出InterruptedException。
public static void main(String[] args) throws InterruptedException {
            Object lock1 = new Object();
            Thread t1 = new Thread(new Test().new Tt1(lock1));
            t1.start();
            Thread.sleep(100);
            t1.interrupt();
        }

        class Tt1 implements Runnable{
            private Object lock1;

            public Tt1(Object lock1) {
                this.lock1 = lock1;
            }

            @Override
            public void run() {
                synchronized (lock1) {
                    try {
                        System.out.println(Thread.currentThread().getName()+"---start");
                        lock1.wait();
                        System.out.println(Thread.currentThread().getName()+"---end");
                    }catch (InterruptedException e) {
                        System.out.println("线程被中断了");;
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
--------------------- 
执行结果：

Thread-0---start
线程被中断了


例子五：
notifyAll和nofity唯一的不同就是，可以唤醒全部和唤醒一个， 先举个nofity的例子
public static void main(String[] args) throws InterruptedException {
            Object lock1 = new Object();
            Thread t1 = new Thread(new Test().new Tt1(lock1));
            Thread t2 = new Thread(new Test().new Tt1(lock1));
            Thread t3 = new Thread(new Test().new Tt2(lock1));
            t1.start();
            Thread.sleep(100);
            t2.start();
            Thread.sleep(100);
            t3.start();
        }

        class Tt1 implements Runnable{
            private Object lock1;

            public Tt1(Object lock1) {
                this.lock1 = lock1;
            }

            @Override
            public void run() {
                synchronized (lock1) {
                    try {
                        System.out.println(Thread.currentThread().getName()+"---start");
                        System.out.println(Thread.currentThread().getName()+"---wait");
                        lock1.wait();
                        System.out.println(Thread.currentThread().getName()+"---end");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        class Tt2 implements Runnable{

            private Object lock1;

            public Tt2(Object lock1) {
                this.lock1 = lock1;
            }

            @Override
            public void run() {
                synchronized (lock1) {
                    try {
                        System.out.println(Thread.currentThread().getName()+"---start");
                        System.out.println(Thread.currentThread().getName()+"---notify");
                        lock1.notify();
                        System.out.println(Thread.currentThread().getName()+"---end");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

            }
        }
--------------------- 
执行结果：

Thread-0---start
Thread-0---wait
Thread-1---start
Thread-1---wait
Thread-2---start
Thread-2---notify
Thread-2---end
Thread-0---end

Thread-0和Thread-1在wait，Thread-2执行了notify，但只有Thread-0被唤醒，重新开始执行，Thread-1还在wait。


例子六：
public static void main(String[] args) throws InterruptedException {
            Object lock1 = new Object();
            Thread t1 = new Thread(new Test().new Tt1(lock1));
            Thread t2 = new Thread(new Test().new Tt1(lock1));
            Thread t3 = new Thread(new Test().new Tt2(lock1));
            t1.start();
            Thread.sleep(100);
            t2.start();
            Thread.sleep(100);
            t3.start();
        }

        class Tt1 implements Runnable{
            private Object lock1;

            public Tt1(Object lock1) {
                this.lock1 = lock1;
            }

            @Override
            public void run() {
                synchronized (lock1) {
                    try {
                        System.out.println(Thread.currentThread().getName()+"---start");
                        System.out.println(Thread.currentThread().getName()+"---wait");
                        lock1.wait();
                        System.out.println(Thread.currentThread().getName()+"---end");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        class Tt2 implements Runnable{

            private Object lock1;

            public Tt2(Object lock1) {
                this.lock1 = lock1;
            }

            @Override
            public void run() {
                synchronized (lock1) {
                    try {
                        System.out.println(Thread.currentThread().getName()+"---start");
                        System.out.println(Thread.currentThread().getName()+"---notifyAll");
                        lock1.notifyAll();
                        System.out.println(Thread.currentThread().getName()+"---end");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }

            }
        }
--------------------- 
执行结果：

Thread-0---start
Thread-0---wait
Thread-1---start
Thread-1---wait
Thread-2---start
Thread-2---notifyAll
Thread-2---end
Thread-1---end
Thread-0---end

Thread-2执行了notifyAll后，Thread-1和Thread-0都被唤醒。在Thread-2执行完成之后，Thread-1和Thread-0都会分别继续执行。

jkkjklmn
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详解java中wait/notifiy/notifyAll，弄清条件队列前因后果
约定明天
07-05 1429
详解java中wait/notifiy/notifyAll1. 基础使用方法2. 状态依赖性的管理2.1 什么是状态依赖性2.1.1 定义2.1.2 单线程和多线程的状态依赖性2.2 内置条件队列2.3 前提条件失败传递给调用者2.4 使用轮询与休眠解决状态依赖性问题2.5 使用内置条件队列解决状态依赖性问题2.6 小结3 使用条件队列3.1 条件谓词3.2 等待/通知标准形式3.3 三元关系3....
wait和notify讲解
08-30
wait和notify讲解
java多线程（7）wait()、notify()和notityALL()
I am a coder
11-30 431
wait wait方法是Object中的方法，这个方法的功能特性： 1).执行wait方法的前提是当前线程已经获取到对象的锁，也就是wait方法必须在synchronized修饰的代码块或者方法中使用。 2).执行wait之后，会失去锁的所有权 3).wait方法执行后会一直等待，直到被调用notify()、notifyAll()或者所在线程被中断。 4).被调用notify()或者no...
C++11 新特性：多线程支持 - notify_all 的用法
最新发布
kelvin_yin的专栏
04-24 457
C++11 notify_all 方法用于唤醒所有等待该条件变量的线程，是在某些条件变化对所有等待线程都是有意义时的理想选择。
java并发编程-线程间协作的两种方式：wait、notify、nitifyAll和Condition
cpf2016的专栏
01-29 590
1.问题引入          线程之间也是需要协作的，比如生产者-消费者模型：当队列满时， 生产者需要等待队列中有空间才能够向里面放入物品，而在等待的时间内，生产者必须释放对资源（队列）的占有权。因为如果生产者不释放对资源的占有权，那么消费者就无法从队列中取出物品，就不会让队列有空间，进而生产者就会一直无限等待下去。因此，一般情况下，当队列满时，会让生产者交出占有权，并进入挂起状态。然后等待消
java多线程notifyall_java多线程（7）wait()、notify()和notityALL()
weixin_35728532的博客
02-25 177
waitwait方法是Object中的方法，这个方法的功能特性：1).执行wait方法的前提是当前线程已经获取到对象的锁，也就是wait方法必须在synchronized修饰的代码块或者方法中使用。2).执行wait之后，会失去锁的所有权3).wait方法执行后会一直等待，直到被调用notify()、notifyAll()或者所在线程被中断。4).被调用notify()或者notifyAll()后...
并发 · 五 —— 使用wait()、notify()、notityAll()实现线程之间的协作
一个有梦想的码农的博客
06-19 236
当涉及一种场景，线程A需要等待线程B完成工作后再开始工作，这时就需要使用到Object基类中的wait()、notify()和notifyAll()来实现，先上例子 public class text { volatile static boolean ok = false; static Object object = new Object(); public s...
详细分析java线程wait和notify
09-03
Java中的`wait()`和`notify()`方法是多线程编程中的关键工具，用于线程间的同步和通信。这两个方法都是Object类的成员，这意味着所有Java对象都可以使用它们。`wait()`方法使当前线程暂停执行并释放它持有的锁，直到...
Java wait和notify虚假唤醒原理
08-19
Java中的`wait()`和`notify()`是用于多线程同步的关键方法，它们是Object类的成员，因此所有Java对象都可以调用。这两个方法是Java内存模型（JMM）的一部分，用于控制线程间的协作和通信。 `wait()`方法使得当前...
浅谈java多线程wait，notify
08-25
在Java多线程编程中，wait和notify是两个非常重要的机制，用于实现线程之间的通信和同步。在本文中，我们将通过示例代码详细介绍Java多线程wait和notify的使用，帮助读者更好地理解和掌握这两个机制。 wait机制 在...
wait_notify_demo
01-10
`wait()`、`notify()`和`notifyAll()`是Java中的三个关键字，它们属于Object类的方法，主要用于线程间的通信，尤其在实现生产者消费者模式时发挥着重要作用。本文将深入探讨这些方法以及如何在实际场景中应用它们。 ...
wait() 和notify() nofifyAll()
天才樱木
09-14 617
这三个方法由于需要控制对对象的控制权(monitor)，所以属于Object而不是属于线程。 wait(),会把持有该对象线程的对象控制权交出去，然后处于等待状态。 notify()，会通知某个正在等待这个对象的控制权的线程可以继续运行。 nofifyAll(),会通知所有等待这个对象控制权的线程继续运行，如果有多个正在等待该对象控制权时，具体唤醒哪个线程，就由操作系统进行调度。   注...
java多线程之wait/notify/notifyAll
徐海兴的专栏
07-29 285
前言：线程的状态 Java中线程中状态可分为五类：New（新建状态），Runnable（就绪状态），Running（运行状态），Blocked（阻塞状态），Dead（死亡状态），这几种状态的转换如下图 因为wait()等方法执行时需要获得锁，所以需要monitor对象，所以要在Synchronized作用域内执行，否则会报错 wait/notity/noti...
多线程编程 -wait(),notify()/notityAll()方法
小单的博客专栏
12-17 4452
多线程编程 -wait(),notify()/notityAll()方法 先说几点： 一、 注意：这些方法属于Object,而不属于Thread。 二、 notify(); //当调用这个方法时，等待队列里面可能没有等待的线程，那是不是要判断等待对列是否为空才判断执不执行呢，没必要，因为这个耗费不大，就相当于多执行一条语句，所以没必要判断，如果要写判断语句，那么代码还复杂些，所
多线程编程 -wait(),notify()/notityAll()方法 .
For that dream
02-24 538
wait(),notify()/notityAll()方法]关于这两个方法,有很多的内容需要说明.在下面的说明中可能会有很多地方不能一下子明白,但在看完本节后,即使不能完全明白,你也一定要回过头来记住下面的两句话 :[wait(),notify()/notityAll()方法是普通对象的方法(Object超类中实现),而不是线程对象的方法][wait(),notify()/notityAll()
wait以及notify()和notifAll()方法的使用，以及sleep的区别
w3x3g的博客
08-15 279
wait以及notify()和notifAll()方法的使用，以及sleep的区别
读书笔记：notify和notifyAll
笨小孩的博客
07-18 3486
1.由于在技术上可能有多个任务在单个对象上出于wait（）状态，因此使用notifyAll（）比notify（）更安全 2.notify（）在众多等待同一个锁的任务中只有一个被唤醒，如果使用notify，必须保证被唤醒的是正确的任务；为了使用notify，所有任务必须等待相同的条件，如果有很多任务等待不同的条件，不能知道是否唤醒了正确的任务；当条件发生变化时，必须只有一个任务能从中受益。 注：...
notifyAll()方法
teedry的专栏
06-03 3602
首先:使用wait方法和使用synchornized来分配cpu时间是有本质区别的。wait会释放锁，synchornized不释放锁。还有：（wait/notify/notifyAll）只能在取得对象锁的时候才能调用。调用notifyAll通知所有线程继续执行，只能有一个线程在执行其余的线程在等待(因为在所有线程被唤醒的时候在synchornized块中)。这时的等待和调用notifyAll前的
java多线程编程 - 基础篇（四）[wait(),notify()/notityAll()方法]
lifesounds的专栏
11-13 1415
java多线程编程 - 基础篇（四）[wait(),notify()/notityAll()方法]   来源于：转载自dev2dev网友axman的go deep into java专栏。　　关于这两个方法,有很多的内容需要说明.在下面的说明中可能会有很多地方不能一下子明白,但在看完本节后,即使不能完全明白,你也一定要回过头来记住下面的两句话: 　　[wait(),notify()
wait和notify
03-23
wait和notify是Java中的线程同步机制，用于实现线程之间的协作。wait方法会使当前线程进入等待状态，直到其他线程调用notify方法唤醒它；而notify方法则会唤醒一个正在等待的线程。这两个方法通常与synchronized...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值