Java多线程之停止wait 和唤醒notify

最新推荐文章于 2024-07-15 21:41:00 发布

糊糊67

最新推荐文章于 2024-07-15 21:41:00 发布

阅读量1.5k

点赞数 1

分类专栏： JavaSE

本文链接：https://blog.csdn.net/weixin_43249530/article/details/88089420

版权

JavaSE 专栏收录该内容

61 篇文章 0 订阅

订阅专栏

生产者和消费者模型：
通过一个容器来解决生产者和消费者的强耦合问题，生产者和消费者之间通过阻塞队列来进行通讯，生产者生产完商品交给阻塞队列，消费者通过阻塞队列取商品，阻塞队列相当于缓冲区，平衡了生产者和消费者的处理能力
在这里插入图片描述

一、wait()方法

就是使线程停止运行。
方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法是用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。
wait()方法只能在同步方法中或同步块中调用，调用wait()时，没有持有适当的锁，会抛出异常。
wait()方法执行后，当前线程释放锁，线程与其它线程竞争重新获取锁。

Object object=new Object();
synchronized(object){
    System.out.println("等待中");
    object.wait();
    System.out.println("等待已过");
}
System.out.println("main方法结束");
输出结果为等待中，因为没有唤醒

二、notify方法

就是使停止的线程继续运行，唤醒等待中的线程。
方法notify()也要在同步方法或同步块中调用，该方法是用来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。如果有多个线程等待，则有线程规划器随机挑选出一个呈wait状态的线程。
在notify()方法后，当前线程不会马上释放该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出同步代码块之后才会释放对象锁

public class Wait {
    public static void main(String[] args) throws InterruptedException {
        Object obj = new Object();
        MThread waitThread = new MThread(true, obj);
        MThread notifyThread = new MThread(false, obj);
        Thread thread1 = new Thread(waitThread, "wait线程");
        Thread thread2 = new Thread(notifyThread, "notify线程");
        thread1.start();
        Thread.sleep(1000);
        thread2.start();
        System.out.println("main方法结束!!");

    }
}

class MThread implements Runnable {
    private boolean flag;
    private Object obj;
    public MThread(boolean flag, Object obj) {
        super();
        this.flag = flag;
        this.obj = obj;
    }

    public void waitMethod() {
        synchronized (obj) {
            try {
                while (true) {
                    System.out.println("wait方法开始" + Thread.currentThread().getName());
                    obj.wait();
                    System.out.println("wait()方法结束.. " +
                            Thread.currentThread().getName());
                    return;

                }
            } catch (Exception e) { 
                e.printStackTrace();
            }

        }
    }

    public void notifyMethod() {
        synchronized (obj) {
            try {
                System.out.println("notify()方法开始.. " +
                        Thread.currentThread().getName());
                obj.notify();
                System.out.println("notify()方法结束.. " +
                        Thread.currentThread().getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    @Override
    public void run() {
        if (flag) {
            this.waitMethod();
        } else {
            this.notifyMethod();
        }
    }
}
wait方法开始wait线程
main方法结束!!
notify()方法开始.. notify线程
notify()方法结束.. notify线程
wait()方法结束.. wait线程

第一个方法是一个死循环使用了wait方法进入等待状态将释放锁，如果这个线程不被唤醒的话将会一直等待下去，第二个方法执行了一个唤醒的操作，并且一直将notify的同步代码块执行完毕后才释放锁然后执行wait的结束打印语句
wait方法和notify方法必须使用在synchronized同步方法或者代码块内

三、 notifyAll()方法

用于一次性唤醒多个在等待的线程
注意：唤醒线程不能过早，如果在还没有线程在等待中时，过早的唤醒线程，这个时候就会出现先唤醒，在等待的效果了。这样就没有必要在去运行wait方法，所以wait在唤醒之前执行

public class Wait {
    public static void main(String[] args) throws InterruptedException {
         Object object = new Object();
        MThread waitThread1 = new MThread(true, object);
        MThread waitThread2 = new MThread(true, object);
        MThread waitThread3 = new MThread(true, object);
        MThread notifyThread = new MThread(false, object);
        Thread thread1 = new Thread(waitThread1, "wait线程A");
        Thread thread2 = new Thread(waitThread2, "wait线程B");
        Thread thread3 = new Thread(waitThread3, "wait线程C");
        Thread thread4 = new Thread(notifyThread, "notify线程");
        thread1.start();
        thread2.start();
        thread3.start();
        Thread.sleep(1000);
        thread4.start();
        System.out.println("main方法结束!!");

    }
}

class MThread implements Runnable {
    private boolean flag;
    private Object obj;
    public MThread(boolean flag, Object obj) {
        super();
        this.flag = flag;
        this.obj = obj;
    }

    public void waitMethod() {
        synchronized (obj) {
            try {
                while (true) {
                    System.out.println("wait方法开始" + Thread.currentThread().getName());
                    obj.wait();
                    System.out.println("wait()方法结束.. " +
                            Thread.currentThread().getName());
                    return;

                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    public void notifyMethod() {
        synchronized (obj) {
            try {
                System.out.println("notify()方法开始.. " +
                        Thread.currentThread().getName());
              //  obj.notify();
                obj.notifyAll();
                System.out.println("notify()方法结束.. " +
                        Thread.currentThread().getName());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


    @Override
    public void run() {
        if (flag) {
            this.waitMethod();
        } else {
            this.notifyMethod();
        }
    }
}
wait方法开始wait线程C
wait方法开始wait线程B
wait方法开始wait线程A
main方法结束!!
notify()方法开始.. notify线程
notify()方法结束.. notify线程
wait()方法结束.. wait线程A
wait()方法结束.. wait线程B
wait()方法结束.. wait线程C