Java——多线程高并发系列之wait()、notify()、notifyAll()、interrupt()-阿里云开发者社区

文章目录：

写在前面

首先需要说一下：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();
        }
    }
}

Java——多线程高并发系列之wait()、notify()、notifyAll()、interrupt()

文章目录：

写在前面

Demo1（不在同步代码块中调用wait方法，则产生java.lang.IllegalMonitorStateException 运行时异常）

Demo2（调用wait方法会使执行当前代码的线程进入等待状态）

Demo3（notify方法会唤醒之前执行wait方法等待的线程）

Demo4（wait() & notify()）

Demo5（interrupt()）

Demo6（notifyAll()）

Demo7（wait(long)）

Demo8（notify方法唤醒过早，可能会打乱程序正常的执行逻辑）

Demo9（notify方法如果唤醒过早，那就不需要让线程继续等待了）

Demo10（wait等待条件发生了变化）

热门文章

最新文章

相关课程

相关电子书

相关实验场景