文章目录：
Demo1（不在同步代码块中调用wait方法，则产生java.lang.IllegalMonitorStateException 运行时异常）
Demo2（调用wait方法会使执行当前代码的线程进入等待状态）
Demo3（notify方法会唤醒之前执行wait方法等待的线程）
Demo8（notify方法唤醒过早，可能会打乱程序正常的执行逻辑）
Demo9（notify方法如果唤醒过早，那就不需要让线程继续等待了）
写在前面
首先需要说一下：wait()、notify()、notifyAll()这三个方法并不是线程类中的方法，而是Object类中的方法，也就是说每个对象都有这三个方法。而interrupt()才是线程类中的方法。
Object 类中的 wait()方法可以使执行当前代码的线程等待,暂停执行,直到接到通知或被中断为止.
注意: ① wait()方法只能在同步代码块中由锁对象调用。②调用 wait()方法,当前线程会释放锁。
Object 类的 notify()可以唤醒线程，该方法也必须在同步代码块中由锁对象调用。没有使用锁对象调用 wait()/notify() 会抛出 IlegalMonitorStateExeption 异常。如果有多个等待的线程，notify()方法只能唤醒其中的一个，在同步代码块中调用notify()方法后，并不会立即释放锁对象，需要等当前同步代码块执行完后才会释放锁对象，一般将 notify()方法放在同步代码块的最后。
下面我给出自己写好的一些代码案例，来帮助大家更好的理解这四个方法的使用，因为代码中已经包含了必要的注释信息，所以每个Demo下面我就只附上代码和运行结果图了。。。
Demo1（不在同步代码块中调用wait方法，则产生java.lang.IllegalMonitorStateException 运行时异常）
package com.szh.wait; /** * wait()方法是Object类中的方法，是每一个对象都具有的方法 * 调用wait()方法的代码块必须放在同步代码块中 * 否则会产生 java.lang.IllegalMonitorStateException 异常 */ public class Test01 { public static void main(String[] args) { String test="szh"; try { test.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } }
Demo2（调用wait方法会使执行当前代码的线程进入等待状态）
package com.szh.wait; /** * wait()方法会使调用它的线程进行等待 * test对象调用了wait()方法，那么synchronized同步代码块中的锁对象就应该是test * 否则程序会产生运行时异常 java.lang.IllegalMonitorStateException */ public class Test02 { public static void main(String[] args) { String test="szh"; System.out.println("同步前的代码..."); synchronized (test) { System.out.println("同步代码块开始..."); try { //调用wait方法后，当前线程就会等待，同时释放test锁对象 //当前线程需要被唤醒，如果没有唤醒就会一直等待 test.wait(); System.out.println("wait方法后面的代码..."); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("main线程后面的代码..."); } }
Demo3（notify方法会唤醒之前执行wait方法等待的线程）
package com.szh.wait; /** * 需要notify()方法唤醒等待的线程 */ public class Test03 { public static void main(String[] args) { String test="szh"; //wait() Thread t1=new Thread(new Runnable() { @Override public void run() { synchronized (test) { System.out.println("线程t1开始等待：" + System.currentTimeMillis()); try { //t1线程这里执行wait方法之后，会立刻释放它占有的test对象的锁 test.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程t1结束等待：" + System.currentTimeMillis()); } } }); //定义t2线程，负责唤醒t1线程 Thread t2=new Thread(new Runnable() { @Override public void run() { synchronized (test) { System.out.println("线程t2开始唤醒：" + System.currentTimeMillis()); //t2线程这里执行notify方法之后，并不会立刻释放它占有的test对象的锁，而是等到同步代码块执行完才会释放 test.notify(); System.out.println("线程t2结束唤醒：" + System.currentTimeMillis()); } } }); t1.start(); //开启t1线程，t1开始等待 try { Thread.sleep(1000 * 3); //main主线程睡眠3秒，确保t1进入等待状态 } catch (InterruptedException e) { e.printStackTrace(); } t2.start(); //t1线程开启3秒后，再开启t2线程，让它唤醒t1线程 } }
Demo4（wait() & notify()）
package com.szh.wait; import java.util.ArrayList; import java.util.List; /** * wait() & notify() */ public class Test04 { public static void main(String[] args) { //定义一个List集合存储String数据 List<String> list=new ArrayList<>(); //定义第一个线程，当list集合中的元素数量不等于5时，该线程等待 Thread t1=new Thread(new Runnable() { @Override public void run() { synchronized (list) { if (list.size() != 5) { System.out.println("线程t1开始等待：" + System.currentTimeMillis()); try { //此时线程t1进入等待状态，会立刻释放它占有的list锁对象，然后线程t2执行 list.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程t1被唤醒了，结束等待：" + System.currentTimeMillis()); } } } }); //定义第二个线程，想list集合中存储元素，当list集合中元素数量为5时，唤醒t1线程 Thread t2=new Thread(new Runnable() { @Override public void run() { synchronized (list) { for (int i = 0; i < 10; i++) { list.add("data ---> " + i); System.out.println("线程t2向list集合中添加了第" + (i+1) + "个元素"); if (list.size() == 5) { //当向list集合中添加了5个元素之后，其size等于5，这时候线程t2执行唤醒线程t1的操作 //但是此时，线程t2并不会立刻释放它占有的list锁对象，而是等这个同步代码块全部执行完毕，才会释放 //执行完毕的时候，线程t2已经向list集合中添加了10个元素，此时才会释放list锁对象，之后程序会转到28行执行 list.notify(); System.out.println("线程t2发出了唤醒线程t1的通知..."); } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } } } }); t1.start(); try { //为了确保t2在t1之后执行，让t1先等待，这里先让main线程睡眠1秒 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } t2.start(); } }
Demo5（interrupt()）
package com.szh.wait; /** * interrupt()方法会中断 wait() 的等待 * wait() 方法的中断会产生 InterruptedException 异常 * 中断之后，该线程也会释放锁对象 */ public class Test05 { //定义常量作为锁对象 private static final Object OBJ=new Object(); public static void main(String[] args) { SubThread t=new SubThread(); t.start(); try { //main主线程睡眠2秒，确保子线程t储与wait等待状态 Thread.sleep(1000 * 2); } catch (InterruptedException e) { e.printStackTrace(); } //线程t执行中断操作 t.interrupt(); } static class SubThread extends Thread { @Override public void run() { synchronized (OBJ) { System.out.println("begin wait..."); try { OBJ.wait(); } catch (InterruptedException e) { System.out.println("wait方法的等待被中断了..."); } } } } }
Demo6（notifyAll()）
package com.szh.wait; /** * notify() & notifyAll() * notify() 一次只能唤醒一个线程,如果有多个等待的线程,只能随机唤醒其中的某一个; * 想要唤醒所有等待线程,需要调用 notifyAll() */ public class Test06 { public static void main(String[] args) { Object obj=new Object(); SubThread t1=new SubThread(obj); SubThread t2=new SubThread(obj); SubThread t3=new SubThread(obj); t1.setName("t1"); t2.setName("t2"); t3.setName("t3"); t1.start(); t2.start(); t3.start(); try { Thread.sleep(1000 * 2); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (obj) { /* 调用一次 notify() 只能唤醒其中的一个线程,其他等待的线程依然处于等待状态, 对于处于等待状态的线程来说,错过了通知信号,这种现象也称为信号丢失 */ //lock.notify(); //唤醒所有的线程 obj.notifyAll(); } } static class SubThread extends Thread { private Object obj; public SubThread(Object obj) { this.obj = obj; } @Override public void run() { synchronized (obj) { System.out.println(Thread.currentThread().getName() + " ---> begin wait..."); try { obj.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " ---> end wait..."); } } } }
Demo7（wait(long)）
package com.szh.wait; /** * wait(long): 带有 long 类型参数的 wait()等待, * 如果在参数指定的时间内没有被唤醒,超时后会自动唤醒. */ public class Test07 { private static final Object OBJ=new Object(); public static void main(String[] args) { Thread t=new Thread(new Runnable() { @Override public void run() { synchronized (OBJ) { System.out.println("线程t开始等待..."); try { //如果3000毫秒内，线程t没有被唤醒，则线程t会自动唤醒 OBJ.wait(1000 * 3); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程t结束等待..."); } } }); t.start(); } }
Demo8（notify方法唤醒过早，可能会打乱程序正常的执行逻辑）
package com.szh.wait; /** * 线程 wait()等待后,可以调用 notify()唤醒线程, * 如果 notify()唤醒的过早,在等待之前就调用了 notify() 可能会打乱程序正常的运行逻辑. */ public class Test08 { public static void main(String[] args) { final Object Lock=new Object(); Thread t1=new Thread(new Runnable() { @Override public void run() { synchronized (Lock) { System.out.println("begin wait..."); try { Lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("end wait..."); } } }); Thread t2=new Thread(new Runnable() { @Override public void run() { synchronized (Lock) { System.out.println("begin notify..."); Lock.notify(); System.out.println("end notify..."); } } }); //如果先开启 t1 线程,再开启 t2 线程, 大多数情况下, t1 先等待, 之后 t2 再把 t1 唤醒，程序正常执行 //t1.start(); //t2.start(); //如果先开启 t2 通知线程, 再开启 t1 等待线程, 可能会出现 t1 线程一直等待(因为t2线程已经唤醒过了，不会再次唤醒了)， //所以t1线程就没有收到 t2 线程唤醒它的通知，t1线程就会一直等待下去 t2.start(); t1.start(); //调用start方法的顺序不一定就是线程实际开启的顺序 } }
Demo9（notify方法如果唤醒过早，那就不需要让线程继续等待了）
package com.szh.wait; /** * notify()通知过早, 就不让线程继续等待了 */ public class Test09 { static boolean isFirst=true; public static void main(String[] args) { final Object Lock=new Object(); Thread t1=new Thread(new Runnable() { @Override public void run() { synchronized (Lock) { while (isFirst) { //当线程t1是第一个开启的线程时，就等待 System.out.println("begin wait..."); try { Lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("end wait..."); } } } }); Thread t2=new Thread(new Runnable() { @Override public void run() { synchronized (Lock) { System.out.println("begin notify..."); Lock.notify(); System.out.println("end notify..."); isFirst=false; //线程t2通知后,就把第一个线程的标志修改为false } } }); //如果先开启 t1 线程,再开启 t2 线程, 大多数情况下, t1 先等待, 之后 t2 再把 t1 唤醒 // t1.start(); // t2.start(); //如果先开启 t2 通知线程, 再开启 t1 等待线程, 可能会出现 t1 线程一直等待，没有收到 t2 线程唤醒它的通知 t2.start(); t1.start(); //调用start方法的顺序不一定就是线程实际开启的顺序 } }
Demo10（wait等待条件发生了变化）
package com.szh.wait; import java.util.ArrayList; import java.util.List; /** * wait 条件发生变化 * 定义一个集合 * 定义一个线程向集合中添加数据, 添加完数据后通知另外的线程从集合中取数据 * 定义一个线程从集合中取数据, 如果集合中没有数据就等待 */ public class Test10 { public static void main(String[] args) { //定义添加数据的线程对象 ThreadAdd threadAdd=new ThreadAdd(); threadAdd.setName("threadAdd"); //定义取数据的线程对象 ThreadSubtract threadSubtract=new ThreadSubtract(); threadSubtract.setName("threadSubtract"); //测试一：先开启添加数据的线程，再开启取数据的线程，大多数情况下会正常的存取数据 // threadAdd.start(); // threadSubtract.start(); //测试二：先开启取数据的线程，再开启添加数据的线程，取数据的线程会先等待，等到添加数据之后，再取数据 // threadSubtract.start(); // threadAdd.start(); //测试三: 开启两个取数据的线程，再开启添加数据的线程，此时运行会产生 java.lang.IndexOutOfBoundsException 异常 ThreadSubtract threadSubtract2 = new ThreadSubtract(); threadSubtract2.setName("threadSubtract2"); threadSubtract.start(); threadSubtract2.start(); threadAdd.start(); } //1.定义一个集合 static List<String> list=new ArrayList<>(); //2.定义方法，从集合中取数据 public static void subtract() { synchronized (list) { while (list.size() == 0) { System.out.println(Thread.currentThread().getName() + " begin wait..."); try { list.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + " end wait..."); } Object obj=list.remove(0); System.out.println(Thread.currentThread().getName() + "从集合中取了" + obj + "后，集合中数据的数量：" + list.size()); } } //3.定义方法，向集合中添加数据 public static void add() { synchronized (list) { list.add("data"); System.out.println(Thread.currentThread().getName() + "向集合中存储了一个数据"); list.notifyAll(); } } //4.定义线程类调用 add() 取数据的方法 static class ThreadAdd extends Thread { @Override public void run() { add(); } } //5.定义线程类调用 subtract() 方法 static class ThreadSubtract extends Thread { @Override public void run() { subtract(); } } }
