线程番外篇(一)wait(),notify(),notifyAll()

朴灿烈づ我的快乐病毒、 2024-02-17 17:33 31阅读 0赞

我们在线程的整理学习中归纳过了生产者和消费者模型,大家有没有注意到我们在生产者消费者模型中使用到了线程之间的交互,就是线程的通信问题:wait()线程等待,notify(),线程唤醒,其实他还有一个唤醒方法就是notifyAll();今天我们就来总结,学习一下线程的这几方法的使用和含义:

1.wait(),wait方法呢就是让调用该方法的线程等待,即进入等待队列,要求就是调用该方法的线程必须拥有该对象的监控锁monitor.

2.notify(),notify()方法就是对应的wait()方法的,总不能让一个线程调用了wait()方法之后睡死过去把,这个也太不人到了,而且是机器残忍的.所以这个notify()方法就出现啦,这个方法呢就是唤醒正在沉睡的线程,也就是之前调用wait()方法的线程,但是要是这个对象监控上有多个wait()的线程的话,那就只能是调用其中的一个,至于调用哪一个我们不得而知,既然是调用一个,那么这个对象锁肯定是交给这个线程啦.

3.notify(),notify()函数就比较吊了,为啥呢,就像这个函数的字面意思一样,他可以同时唤醒,这个对象锁上的等待的所有的线程,也就是说要是这个对象锁上面等待了多个线程,那么他一次性就会调用所有等待的线程,但是呢他和notify()方法一样也是不能决定具体让那个唤醒的线程去获得这个对象锁并执行,他只是唤醒他们而已.

还有需要注意的一点:

1.就是这个几个方法都是作用在同步代码块中的,为什么呢,这个从我们一致强调的语言中就能很明白的知道,他们是基于对象锁的,既然要牵扯到锁,那肯定是在同步代码快上啦.

2.还有一点就是,有人会说为啥线程的wait()方法,和notify(),notifyAll()不是Thread类的方法,而要作为Object 的方法呢,这个其实就是1,个是因为Thread是继承Object的,最主要的原因其实是因为我们的wait()和notify(),notifyAll()都是对应的对象锁,对象锁,!!!!不是线程啦,而且要是线程的话,由于多线程的执行的复杂性,也不好管理,所以人家是有道理的.

3.第三一点就是关于锁的获取和释放了,当一个线程获取对象锁调用wait()方法的时候其实他是放弃了这个对象的锁进入到等待状态的,意思就是说他执行完了synchronized的代码才进入到等待状态的,相应的notify()方法也是同样的道理,要是调用了notify()函数的话也是等待synchronized包含的代码快或者方法,执行结束才是放掉对象锁,在通知别的线程进行对象锁的获取.

来看一下我们的这几个方法的使用吧:

/**
     * Created by luyangli on 16-6-21.
     */
    public class WaitAndNotify {
    
        public static void main(String[] args) {
            Object object = new Object();  //同步的对象
            Thread1 thread1 = new Thread1(object);
            Thread2 thread2 = new Thread2(object);
    
            thread1.start();
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            thread2.start();
        }
    
        static class Thread1 extends Thread {
            private Object object;
    
            public Thread1(Object object) {
                this.object = object;
            }
    
            @Override public void run() {
                synchronized (object) {
                    System.out.println("线程:" + Thread.currentThread().getName() + "获取到了对象锁!");
                    try {
                        object.wait();
                    } catch (InterruptedException e) {
    
                    }
                    System.out.println("线程:" + Thread.currentThread().getName() + "调用wait()方法释放了对象锁!");
                }
            }
        }
    
        static class Thread2 extends Thread {
    
            private Object object;
    
            public Thread2(Object object) {
                this.object = object;
            }
    
            @Override public void run() {
                synchronized (object) {
                    System.out.println("线程:" + Thread.currentThread().getName() + "获取到了对象锁!");
                    object.notify();
                }
                System.out.println("线程:" + Thread.currentThread().getName() + "调用notify()方法释放了对象锁!");
            }
        }
    }我们结果是一直不变的,我们可以分析下:

首先我们创建了一个线程让线程获取到对象锁之后调用wait()方法,在调用了wait()方法之后线程执行完synchronized里的代码然后就放弃对象锁等待,知道第二个线程获取对象锁执行notify()方法唤醒线程1,但是呢在唤醒线程1之前他是必须执行完临界区中的代码的,所以我们的分析就是这样,我们来看下验证结果把:

线程:Thread-0获取到了对象锁!
    线程:Thread-1获取到了对象锁!
    线程:Thread-1调用notify()方法释放了对象锁!
    线程:Thread-0调用wait()方法释放了对象锁!

这个就是我们的wait()和notify();

相对应的,我们的这个notify()和wait()有一个同等作用的方法,那就是Condition类里的await()和signal(),这个我们在后面的博文中在共同学习.