文章目录:
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(); } } }