wait()、notify()/notifyAll()、join()方法的应用

最新推荐文章于 2022-07-11 11:49:17 发布

Martiny66

最新推荐文章于 2022-07-11 11:49:17 发布

阅读量482

点赞数 1

分类专栏： Java并发文章标签： wait notify CountDownLatch

本文链接：https://blog.csdn.net/xzx4959/article/details/83245905

版权

Java并发专栏收录该内容

19 篇文章 0 订阅

订阅专栏

1.4 notify和notifyAll的区别

2.join()方法

在了解如何使用wait()和notify/notifyAll实现线程之间的通信之前，我们先做出如下的总结：

线程在执行yield()之后，线程状态由运行中状态转为就绪状态，持有的锁不释放
sleep()方法被调用之后，持有的锁是不释放的。
wait和notify必须配合synchronized去使用。调用了wait()方法以后，锁就会被释放，当wait()方法返回的时候，线程会重新持有锁；调用notify()方法之前，必须要持有锁，调用notify()方法本身不会释放锁。

1.wait和notify

1.1 简单应用

使用wait和notify设计如下程序，t1线程向一个List中添加元素，当List的长度为5时向t2线程发出通知；t2等待线程t1的通知，当t2线程接收到t1的通知时，中断线程。程序代码如下：

public class ListAdd {
    private volatile static List list = new ArrayList();

    public void add() {
        list.add("Hello World");
    }

    public int size() {
        return list.size();
    }

    public static void main(String[] args) {

        final ListAdd listAdd = new ListAdd();

        // 实例化出来一个 lock
        // 当使用wait 和 notify 的时候 ， 一定要配合着synchronized关键字去使用
        final Object lock = new Object();

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    synchronized (lock) {
                        for (int i = 0; i < 10; i++) {
                            listAdd.add();
                            System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素..");
                            Thread.sleep(500);
                            if (listAdd.size() == 5) {
                                System.out.println("已经发出通知..");
                                lock.notify();
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    if (listAdd.size() != 5) {
                        try {
                            System.out.println("t2进入...");
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止..");
                    throw new RuntimeException();
                }
            }
        }, "t2");
        t2.start();
        t1.start();
    }
}

程序的运行结果如下：

t2进入...
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
已经发出通知..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
10
当前线程：t2收到通知线程停止..
Exception in thread "t2" java.lang.RuntimeException
	at com.bjsxt.base.conn008.ListAdd$2.run(ListAdd.java:66)
	at java.lang.Thread.run(Thread.java:748)

首先声明一个lock锁对象，然后启动t2线程，获得lock锁，此时list中的元素等于5，t2线程等待并释放锁。 t1线程获得lock锁，循环执行元素添加操作，当list的长度为5的时候，发送notify通知，但t1线程仍然持有lock锁，继续执行，直到线程执行结束释放锁。t2线程重新获得lock锁，并被唤醒，继续执行程序到结束。

1.2 CountDownLatch

上面的程序存在什么样的问题呢？

在上面的程序中，当list元素达到5个的时候，并没有实时的去释放锁，而必须等到程序执行结束，如果我们想实时的释放锁可以使用CountDownLatch，CountDownLatch无需配合synchronized关键字去使用。

public class ListAdd2 {
    private volatile static List list = new ArrayList();

    public void add() {
        list.add("Hello World");
    }

    public int size() {
        return list.size();
    }

    public static void main(String[] args) {

        final ListAdd2 list2 = new ListAdd2();

        // 构造函数中的数字表示countDown调用的次数
        final CountDownLatch countDownLatch = new CountDownLatch(1);

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 10; i++) {
                        list2.add();
                        System.out.println("当前线程：" + Thread.currentThread().getName() + "添加了一个元素..");
                        if (list2.size() == 5) {
                            System.out.println("已经发出通知..");
                            countDownLatch.countDown();
                        }
                        Thread.sleep(500);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                if (list2.size() != 5) {
                    try {
                        System.out.println("t2进入...");
                        countDownLatch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("当前线程：" + Thread.currentThread().getName() + "收到通知线程停止..");
                throw new RuntimeException();
            }
        }, "t2");
        t2.start();
        t1.start();
    }
}

执行结果如下：

t2进入...
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
已经发出通知..
当前线程：t2收到通知线程停止..
Exception in thread "t2" java.lang.RuntimeException
	at com.bjsxt.base.conn008.ListAdd2$2.run(ListAdd2.java:67)
	at java.lang.Thread.run(Thread.java:748)
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..
当前线程：t1添加了一个元素..

从执行结果我们可以看出，list中的元素达到5个的时候，等待的线程t2会立即得到执行，此时t1线程会继续执行，并不会受到阻塞。final CountDownLatch countDownLatch = new CountDownLatch(1)中的构造函数数字，表示t2线程继续执行时countDown需要调用的次数。

1.3 wait和notify实现队列

使用wait和notify实现一个BlockingQueue（阻塞队列），支持阻塞的放入和得到数据。需要实现两个简单的方法put和take操作。

put(anObject)：把anObject加到Blocking里。如果BlockingQueue中没有空间，则调用此方法的线程被阻塞，直到BlockingQueue里面有空间再继续。

take：取走BlockingQueue里排在首位的对象，若BlockingQueue为空，阻塞进入等待状态直到BlockingQueue有新的数据被加入。

public class MyQueue {

    //1 需要一个承装元素的集合 
    private LinkedList<Object> list = new LinkedList<Object>();
    //2 需要一个计数器
    private AtomicInteger count = new AtomicInteger(0);
    //3 需要制定上限和下限
    private final int minSize = 0;
    private final int maxSize;

    //4 构造方法
    public MyQueue(int size) {
        this.maxSize = size;
    }

    //5 初始化一个对象 用于加锁
    private final Object lock = new Object();

    //put(anObject): 把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断，直到BlockingQueue里面有空间再继续.
    public void put(Object obj) {
        synchronized (lock) {
            while (count.get() == this.maxSize) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //1 加入元素
            list.add(obj);
            //2 计数器累加
            count.incrementAndGet();
            //3 通知另外一个线程（唤醒）
            lock.notify();
            System.out.println("新加入的元素为:" + obj);
        }
    }

    //take: 取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到BlockingQueue有新的数据被加入.
    public Object take() {
        Object ret = null;
        synchronized (lock) {
            while (count.get() == this.minSize) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //1 做移除元素操作
            ret = list.removeFirst();
            //2 计数器递减
            count.decrementAndGet();
            //3 唤醒另外一个线程
            lock.notify();
        }
        return ret;
    }

    public int getSize() {
        return this.count.get();
    }

    public static void main(String[] args) {

        final MyQueue mq = new MyQueue(5);
        mq.put("a");
        mq.put("b");
        mq.put("c");
        mq.put("d");
        mq.put("e");

        System.out.println("当前容器的长度:" + mq.getSize());

        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                mq.put("f");
                mq.put("g");
            }
        }, "t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                Object o1 = mq.take();
                System.out.println("移除的元素为:" + o1);
                Object o2 = mq.take();
                System.out.println("移除的元素为:" + o2);
            }
        }, "t2");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

程序的执行结果如下：

新加入的元素为:a
新加入的元素为:b
新加入的元素为:c
新加入的元素为:d
新加入的元素为:e
当前容器的长度:5
移除的元素为:a
新加入的元素为:f
移除的元素为:b
新加入的元素为:g

1.4 notify和notifyAll的区别

在实际的使用中，notify和notifyAll应该用哪一个呢？

应该尽量使用notifyAll，使用notify有可能发生信号丢失的情况。notifyAll唤醒全部等待的线程，notify只会唤醒一个线程，理论上是唤醒所有处于等待队列的第一个。看如下的实例代码，我们实现了一个快递更新的功能，当一个线程更新了快递状态和快递配送距离之后，发出通知，等待快递状态和配送距离的线程接收到该通知做出相应的处理。发送通知我们首先使用notify实现：

package com.martin.frame.practices.concurrent.chapter1;

/**
 * 快递更新的服务类
 *
 * @author: martin
 * @date: 2020/3/2
 */
public class Express {
    private int km;
    private int state;

    public Express(int km, int state) {
        this.km = km;
        this.state = state;
    }


    public synchronized void updateState(int state, int addKm) {
        this.state = state;
        this.km += addKm;
        System.out.println("发送更新通知:" + state + "," + km);
        notify();
    }

    public synchronized void waitKm() {
        try {
            wait();
            System.out.println("配送距离更新:" + km);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void waitState() {
        try {
            wait();
            System.out.println("配送状态更新:" + state);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试代码：

    public static void expressTest() {
        Express express = new Express(0, 0);
        Thread thread1 = new Thread(() -> {
            SleepTools.second(2);
            express.updateState(1, 100);
        });

        Thread waitKm = new Thread(express::waitKm);
        Thread waitState = new Thread(express::waitState);

        thread1.start();
        waitKm.start();
        waitState.start();
    }

代码输出如下：

发送更新通知:1,100
配送距离更新:100

我们发现更新状态和配送里程之后，只有等待距离的线程接收到通知，等待状态的线程没有被唤醒。这显然不符合我们的预期，发送通知修改为notifyAll，运行代码如下：

发送更新通知:1,100
配送距离更新:100
配送状态更新:1

这样就符合预期了。

2.join()方法

join()方法可以实现线程的顺序执行：线程A执行了线程B的join方法，那么线程A必须要等待B执行完成了之后，线程A才能继续执行。

创建如下的线程执行代码：

package com.martin.frame.practices.concurrent.chapter1;

/**
 * @author: martin
 * @date: 2020/3/2
 */
public class ExecuteBySeq implements Runnable {
    private Thread thread;

    public ExecuteBySeq(Thread thread) {
        this.thread = thread;
    }

    @Override
    public void run() {
        try {
            thread.join();
            System.out.println(Thread.currentThread().getName() + "执行完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试代码：

    public static void jonTest() {
        Thread current = Thread.currentThread();
        for (int i = 1; i <= 10; i++) {
            Thread thread = new Thread(new ExecuteBySeq(current), String.valueOf(i));
            current = thread;
            thread.start();
        }

        System.out.println("主线程执行完成");
    }

输出的结果如下：

主线程执行完成
1执行完成
2执行完成
3执行完成
4执行完成
5执行完成
6执行完成
7执行完成
8执行完成
9执行完成
10执行完成

Martiny66

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
wait()、notify()/notifyAll()、join()方法的应用

使用wait和notify方法实现线程间的通信需要注意以下两点：wait和notify必须配合synchronized去使用。 wait可以释放锁，notify不释放锁。1.wait和notify的简单应用使用wait和notify设计如下程序，t1线程向一个List中添加元素，当List的长度为5时向t2线程发出通知；t2等待线程t1的通知，当t2线程接收到t1的通知...
复制链接

扫一扫

专栏目录