Java多线程问题--wait()和notify()

本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！

代码地址：https://github.com/xianzhixianzhixian/thread.git

介绍wait()和notify()的使用以及注意事项

1、wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，知道接到通知或被中断位置。在wait()方法调用前，线程必须获得该对象的对象级别锁（注意，是对象级别锁），即只能在同步方法或同步块中调用wait()方法。在执行wait()方法后，当前线程释放锁。在从wait()返回前，线程与其它线程竞争重新获得锁。使用方法：lock.wait()

2、方法notify()也要在同步方法或同步代码块中调用，在调用前线程也必须获得该对象的对象锁。该方法用来通知那些可能在等待该对象的对象锁的其它线程，如果有多个线程等待则由线程规划器随机挑选一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也不能马上获取该对象锁，要等到执notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，呈wait状态所在的线程才可以获取该对象锁。使用方法：lock.notify()

把ThreadA.java和ThreadB.java中的synchronized代码块去掉运行一遍，结果会报java.lang.IllegalMonitorStateException错误，如图所示。这也证明了wait()方法和notify()方法在调用前线程必须获得该对象的对象级别锁（注意，是对象级别锁），即只能在同步方法或同步块中调用。

3、当线程呈wait状态时，调用线程对象的interrupt()方法回出现java.lang.InterruptedException异常。

4、当线程遇到异常终止时，会自动释放占用的锁资源。

5、方法wait(long)的功能是等待某一段时间内是否有线程对锁进行唤醒，如果超过这个时间则自动唤醒。

使用代码示范

MyList.java

package wait.notify;

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

/**
 * wait()和notify()的使用，wait()和notify()只有在线程获得了对象级别的锁之后才可以被使用
 * 即wait()和notify()函数只能在synchronized函数或synchronized代码块中使用
 * @author: xianzhixianzhixian
 * @date: 2018-12-26 23:07
 */
public class MyList {

    private static List<String> list = new ArrayList<>();

    public static void add(){
        list.add("anyString");
    }

    public static int size(){
        return list.size();
    }
}

ThreadA.java

package wait.notify;

/**
 * @author: xianzhixianzhixian
 * @date: 2018-12-26 23:11
 */
public class ThreadA extends Thread {

    private Object lock;

    public ThreadA(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                super.run();
                if (MyList.size() != 5){
                    System.out.println("wait begin "+System.currentTimeMillis());
                    lock.wait();
                    System.out.println("wait end "+System.currentTimeMillis());
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ThreadB.java

package wait.notify;

/**
 * @author: xianzhixianzhixian
 * @date: 2018-12-26 23:11
 */
public class ThreadB extends Thread {

    private Object lock;

    public ThreadB(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                super.run();
                for (int i = 0; i < 10; i++) {
                    MyList.add();
                    if (MyList.size() == 5){
                        System.out.println("已发出通知！");
                        lock.notify();
                    }
                    System.out.println("添加了"+(i+1)+"个元素！");
                    Thread.sleep(1000);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Run.java

package wait.notify;

/**
 * @author: xianzhixianzhixian
 * @date: 2018-12-26 23:16
 */
public class Run {

    public static void main(String[] args) {
        try {
            Object lock = new Object();
            ThreadA a = new ThreadA(lock);
            a.start();
            Thread.sleep(50);
            ThreadB b = new ThreadB(lock);
            b.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：