多线程之等待/通知机制（1）

最新推荐文章于 2024-10-15 19:37:56 发布

道墟

最新推荐文章于 2024-10-15 19:37:56 发布

阅读量323

点赞数

文章标签：多线程 java

本文链接：https://blog.csdn.net/qq_27581753/article/details/106074871

版权

线程与线程之间不是独立的个体，它们彼此之间可以互相通信和协作。

1.不使用等待/通知机制实现线程间通信

使用测试案例中使用sleep()结合while(true)死循环法来实现多个线程通信。测试代码如下：

package threadTest;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author LiBinquan
 */
public class MyList {
    private List list = new ArrayList();
    public void add(){
        list.add("郭靖");
    }
    public int size(){
        return list.size();
    }
}

线程A：

package threadTest;

/**
 * @Author LiBinquan
 */
public class ThreadA extends Thread{
    private MyList list;
    public ThreadA(MyList list){
        super();
        this.list = list;
    }

    @Override
    public void run() {
        try{
            for (int i = 0; i < 10; i++) {
                list.add();
                System.out.println("添加了"+(i+1)+"个元素");
                Thread.sleep(1000);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

线程B:

package threadTest;

/**
 * @Author LiBinquan
 */
public class ThreadB extends Thread{
    private MyList list;
    public ThreadB(MyList list){
        super();
        this.list = list;
    }

    @Override
    public void run() {
        try{
            while (true){
                if (list.size() == 5){
                    System.out.println("==5 了，线程b要退出了！");
                    throw new InterruptedException();
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

运行类：

package threadTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        MyList myList = new MyList();
        ThreadA a  = new ThreadA(myList);
        a.setName("A");
        a.start();
        ThreadB b  = new ThreadB(myList);
        b.setName("B");
        b.start();
    }
}

输出：
在这里插入图片描述
由输出可得，虽然两个线程间实现了通信，但有一个弊端就是，线程ThreadB.java不停地通过while语句轮询机制来监测某一条件，这样会浪费CPU资源。
如果轮询的时间间隔很小，更浪费CPU资源；如果轮询的时间间隔很大，有可能会取不到想要得到的数据。所以就需要有一种机制来实现减少CPU的资源浪费，而且还可以实现在多个线程间通信，它就是“wait/notify”机制。

2.什么是等待/通知机制

等待/通知机制在生活中比比皆是，比如在就餐时就会出现，厨师和服务员之间的交互要在“菜品传递台上”，那么这个时候就会出现几个问题：
1.厨师做完一道菜的时间不确定，所以厨师将菜品放到“菜品传递台”上的时间是不确定的。
2.服务员取到菜的时间取决于厨师，所以服务员就有“等待”（wait）的状态。
3.服务员如何能取到菜呢？这又得取决于厨师，厨师将菜放在“菜品传递台”上，其实就相当于一种通知（notify），这时服务员才可以拿到菜并交给就餐者。
4.在这个过程中出现了“等待/通知”机制。
这边需要说明的是，多个线程之间也可以实现通信，原因是多个线程共同访问同一个变量，但那种通信机制不是"等待/通知",两个线程完全是主动式地读取一个共享变量，在花费读取时间的基础上，读到的值是不是想要的，并不能完全确定。所以现在迫切需要一种“等待/通知”机制来满足上面的需求。

3.等待/通知机制的实现

方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait()所在的代码行处停止执行，直到接到通知或被中断为止。在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。在执行wait()方法后，当前线程释放锁。 在从wait()返回前，线程与其他下次呢灰姑娘竞争重新获得锁。如果调用wait()时没有持有适当的锁，则抛出IllegalMonitorStateException，它是RuntimeException的一个子类，因此，不需要try-catch语句进行捕捉异常。
方法notify()也要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁。 如果调用notify()时没有持有适当的锁，也会抛出IllegalMonitorStateException。该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。需要说明的是，在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait()状态的线程也并不能马上获取该对象锁，要等到执行notify()方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁，而呈wait状态所在的线程才可以获取该对象锁。当第一个获得了该对象锁的wait线程运行完毕以后，它会释放掉该对象锁，此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，还会继续阻塞在wait状态，直到对这个对象发出一个notify或notifyall。
用一句话来总结一下wait和notify：wait使线程停止运行，而notify使停止的线程继续运行。
案例代码如下：

package threadTest;

/**
 * @Author LiBinquan
 */
public class Test1 {
    public static void main(String[] args) {
        try{
            String newString = new String("");
            newString.wait();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

运行效果：
在这里插入图片描述
出现异常时因为没有“对象监视器”，也就是没有同步加锁。
修改后代码如下：

package threadTest;

/**
 * @Author LiBinquan
 */
public class Test2 {
    public static void main(String[] args) {
        try{
            String lock = new String();
            System.out.println("syn上面");
            synchronized (lock){
                System.out.println("syn 第一行");
                lock.wait();
                System.out.println("wait下面一行");
            }
            System.out.println("syn下面一行");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

在这里插入图片描述
输出如上，可以看出wait方法下面就不执行了。
但是线程不能永远等待下去，那样程序就停止不前了，不继续向下运行了。如何使呈等待wait状态的线程继续运行呢？当然是使用notify()方法。
示例代码如下：
线程1

package threadTest;

/**
 * @Author LiBinquan
 */
public class MyThread1 extends Thread{
    private Object lock;
    public MyThread1(Object lock){
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try{
            synchronized (lock){
                System.out.println("开始   wait time = "+System.currentTimeMillis());
                lock.wait();
                System.out.println("结束   wait time = "+System.currentTimeMillis());
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

线程2

package threadTest;

/**
 * @Author LiBinquan
 */
public class MyThread2 extends Thread{
    private Object lock;
    public MyThread2(Object lock){
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock){
            System.out.println("开始   wait time = "+System.currentTimeMillis());
            lock.notify();
            System.out.println("结束   wait time = "+System.currentTimeMillis());
        }
    }
}

运行类：

package threadTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        try{
            Object lock = new Object();
            MyThread1 t1 = new MyThread1(lock);
            t1.start();
            Thread.sleep(3000);
            MyThread2 t2 = new MyThread2(lock);
            t2.start();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述
从输出可以看出，3秒后线程被notify通知唤醒。
重新使用wait()与notify()来实现前面size等于5的示例：

package threadTest;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author LiBinquan
 */
public class MyList {
    private static List list = new ArrayList();
    public static void add(){
        list.add("郭靖");
    }
    public static int size(){
        return list.size();
    }
}

线程a：

package threadTest;

/**
 * @Author LiBinquan
 */
public class ThreadA extends Thread{
    private Object lock;
    public ThreadA(Object lock){
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try{
            synchronized (lock){
                if (MyList.size() !=5 ){
                    System.out.println("wait begin "+System.currentTimeMillis());
                    lock.wait();
                    System.out.println("wait end "+System.currentTimeMillis());
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

线程b：

package threadTest;

/**
 * @Author LiBinquan
 */
public class ThreadB extends Thread{
    private Object lock;
    public ThreadB(Object lock){
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        try{
            synchronized (lock){
                for (int i = 0;i<10;i++){
                    MyList.add();
                    if (MyList.size() == 5){
                        lock.notify();
                        System.out.println("已发出通知！");
                    }
                    System.out.println(
                            "添加了"+(i+1)+"个元素"
                    );
                    Thread.sleep(1000);
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

运行类：

package threadTest;

/**
 * @Author LiBinquan
 */
public class Run {
    public static void main(String[] args) {
        try{
            Object lock = new Object();
            ThreadA a = new ThreadA(lock);
            a.start();
            Thread.sleep(3000);
            ThreadB b = new ThreadB(lock);
            b.start();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

输出：
在这里插入图片描述
日志信息wait end 在最后输出，这也说明notify()方法执行后并不立即释放锁。这个知识点在后面进行补充介绍。
关键字synchronized可以将任何一个Object对象作为同步对象来看待，而Java为每个Object都实现了wait()和notify()方法，它们必须用在被synchronized同步的Object的临界区内。通过调用wait()方法可以使处于临界区内的线程进入等待状态，同时释放被同步对象的锁。而notify操作可以唤醒一个因调用了wait操作而处于阻塞状态中的线程，使其进入就绪状态。被重新唤醒的线程会试图重新获得临界区的的控制权，也就是锁，并继续执行临界区内wait之后的代码。如果发出notify操作时没有处于阻塞状态中的线程，那么该命令会被忽略。
wait()方法可以使调用该方法的线程释放共享资源的锁，然后从运行状态退出，进入等待队列，直到被再次唤醒。
notify()方法可以随机唤醒等待队列中等待同一共享资源的”一个“线程，并使该线程退出等待队列，进入可运行状态，也就是notify()方法仅通知”一个“线程。
notifyAll()方法可以使所有正在等待队列中等待同一共享资源的”全部“线程从等待状态退出，进入可运行状态。此时，优先级最高的那个线程最先执行，但也有可能是随机执行，因为这要取决于JVM虚拟机的实现。
在这里插入图片描述
1.新创建一个新的线程对象后，再调用它的start()方法，系统会为此线程分配CPU资源，使其处于Runnable（可运行）状态，这是一个准备运行的阶段。如果线程抢占到CPU资源，此线程就处于Running（运行）状态。
2.Runnable状态和Running状态可相互切换，因为有可能线程运行一段时间后，有其他高优先级的线程抢占了CPU资源，这时此线程就从Running状态编程Runnable状态。
线程进入Runnable状态大体分为如下5种情况：
1.调用sleep方法后经过的时间超过了指定的休眠时间。
2.线程调用的阻塞IO已经返回，阻塞方法执行完毕。
3.线程成功的获得了试图同步的监视器。
4.线程正在等待某个通知，其它线程发出了通知。
5.处于挂起状态的线程调用了rusume恢复方法。
3.Blocked是阻塞的意思，例如遇到了一个IO操作，此时CPU处于空闲状态，可能会转而把CPU时间片分配给其他线程，这时也可以称为”暂停“状态。Blocked状态结束后，进入Runnable状态，等待系统重新分配资源。
出现阻塞的情况大体分为如下5种：
1.线程调用sleep方法，主动放弃占用的处理器资源。
2.线程调用了阻塞式IO方法，在改方法返回前，该线程被阻塞。
3.线程试图获得一个同步监视器，但该同步监视器正在被其他线程所持有。
4.线程呆呆某个通知。
5.程序调用了suspend方法将该线程挂起。此方法容易导致死锁，尽量避免使用该方法。
4.run()方法运行结束后，进入销毁阶段，整个线程执行完毕。
每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程。一个线程被唤醒后，才会进入就绪队列，等待CPU的调度；反之，一个线程被wait后，就会进入阻塞队列，等待下一次被唤醒。