Java多线程 -- wait() 和 notify() 使用入门

时间  2019-11-17
标签 java 多线程 wait notify 使用 入门 栏目 Java 繁體版
原文   原文链接

在前面讲解synchronize的文章中，有提到wait和notify，大概描述了它的使用，这里我将根据官方api详细的教你如何使用。java

所属对象

wait，notify，notifyAll 是定义在Object类的实例方法，用于控制线程状态。api

文档分析

咱们找到Object类，下载它的文档，翻译每一个方法的注释。bash

总结以下：jvm

  1. wait() 和 notify() 必须由对象持有者去调用，有三种方式： 1️⃣执行该对象的synchronized实例方法 2️⃣执行synchronized代码块 3️⃣执行该类的synchronized静态方法ide

  2. 当想要调用wait( )进行线程等待时，必需要取得这个锁对象的控制权（对象监视器），通常是放到synchronized(obj)代码中。性能

  3. 在while循环里用wait操做性能更好（比if判断）测试

  4. 调用obj.wait( )释放了obj的锁，不然其余线程也没法得到obj的锁，也就没法在synchronized(obj){ obj.notify() } 代码段内唤醒A。ui

  5. notify( )方法只会通知等待队列中的第一个相关线程（不会通知优先级比较高的线程）this

  6. notifyAll( )通知全部等待该竞争资源的线程（也不会按照线程的优先级来执行）spa

  7. 若是是synchronized声明的方法，wait()操做后会施放synchronized锁，相反notify()触发后会重拿起synchronized锁。

  8. 若是当前线程不是当前对象所持有，则会报异常IllegalMonitorStateException

实例

1. 经过调用对象的wait和notify实现
/** 调用对象的 wait 和 notify 实例
 * Created by Fant.J.
 */
public class Demo {
    private boolean flag = false;

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public static void main(String[] args) {
        Demo demo = new Demo();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("修改flag线程执行");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                demo.setFlag(true);
                notify();
                System.out.println("修改flag并释放锁成功");
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (demo.isFlag() != true){
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("flag为true时线程执行");

            }
        }).start();
    }
}



修改flag线程执行
Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
	at java.lang.Object.wait(Native Method)
	at java.lang.Object.wait(Object.java:502)
	at com.thread.waitNotify.Demo$2.run(Demo.java:41)
	at java.lang.Thread.run(Thread.java:748)
Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
	at java.lang.Object.notify(Native Method)
	at com.thread.waitNotify.Demo$1.run(Demo.java:31)
	at java.lang.Thread.run(Thread.java:748)
复制代码

从运行结果能够看出，它报错IllegalMonitorStateException，咱们上面有给出报该异常的缘由，是由于没有没有获取到对象的监视器控制权，咱们new了两个线程，一个调用了wait 一个调用了notify，jvm认为wait是一个线程下的wait，notify是另外一个线程下的notify，事实上，咱们想实现的是针对Demo对象的锁的wait和notify，因此，咱们须要调用Demo对象的wait和notify方法。

修改后的代码：

/** 调用对象的 wait 和 notify 实例
 * Created by Fant.J.
 */
public class Demo {
    private boolean flag = false;

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public static void main(String[] args) {
        Demo demo = new Demo();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (demo) {
                    System.out.println("修改flag线程执行");
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    demo.setFlag(true);
                    demo.notify();
                    System.out.println("修改flag并释放锁成功");
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (demo) {
                    while (demo.isFlag() != true) {
                        try {
                            demo.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("flag为true时线程执行");
                }
            }
        }).start();
    }
}


修改flag线程执行
修改flag并释放锁成功
flag为true时线程执行
复制代码

修改了两处，一处是加了synchronized代码块，一处是添加了wait和notify的调用对象。

2. 经过synchronized修饰方法来实现
package com.thread.waitNotify_1;

/** 经过synchronized方法实现 wait notify
 * Created by Fant.J.
 */
public class Demo2 {
    private volatile boolean flag = false;

    public synchronized boolean getFlag() {
        System.out.println(Thread.currentThread().getName()+"开始执行...");
        if (this.flag != true){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"执行结束...");
        return flag;
    }

    public synchronized void setFlag(boolean flag) {
        this.flag = flag;
        notify();
    }

    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        Runnable target1 = new Runnable() {
            @Override
            public void run() {
                demo2.getFlag();
            }
        };

        Runnable target2 = new Runnable() {
            @Override
            public void run() {
                demo2.setFlag(true);
            }
        };

        new Thread(target1).start();
        new Thread(target1).start();
        new Thread(target1).start();
        new Thread(target1).start();
    }
}


Thread-0开始执行...
Thread-1开始执行...
Thread-2开始执行...
Thread-3开始执行...
复制代码

为何四个线程都执行了呢？synchronized不是锁定线程了吗？我在上面8点中也有说明，wait()操做后，会暂时释放synchronized的同步锁，等notify()触发后，又会重拾起该锁，保证线程同步。

而后咱们条用target2来释放一个线程：

new Thread(target1).start();
        new Thread(target1).start();
        new Thread(target1).start();
        new Thread(target1).start();
        new Thread(target2).start();

Thread-0开始执行...
Thread-1开始执行...
Thread-2开始执行...
Thread-3开始执行...
Thread-0执行结束...

复制代码

能够看到只释放了一个线程，而且是第一个线程，若是有优先级，他也是释放第一个线程。

若是把notify改为notifyAll。

Thread-0开始执行...
Thread-2开始执行...
Thread-1开始执行...
Thread-3开始执行...
Thread-3执行结束...
Thread-1执行结束...
Thread-2执行结束...
Thread-0执行结束...
复制代码

如何证实，每次notify后会拿到synchronized锁呢，我在执行notify后添加一些时间戳捕获帮助咱们查看

public synchronized void setFlag(boolean flag) {
        this.flag = flag;
//        notify();
        notifyAll();
        System.out.println("测试notify触发后会不会等2s"+System.currentTimeMillis());
        try {
            Thread.sleep(2000);
            System.out.println("测试notify触发后会不会等2s"+System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


Thread-0开始执行...
Thread-1开始执行...
Thread-2开始执行...
Thread-3开始执行...
测试notify触发后会不会等2s1529817196847
测试notify触发后会不会等2s1529817198847
Thread-3执行结束...
Thread-2执行结束...
Thread-1执行结束...
Thread-0执行结束...
复制代码

能够看到的确是notify重拾了synchronized的同步锁，执行完该方法后才会释放锁。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程