线程之间通信 等待(wait)和通知(notify)及Queue的模拟

本文介绍了线程通信的概念及其在Java中的实现方式,包括wait()和notify()方法的应用,并通过实例展示了如何使用这两种方法实现线程间的有效协作。此外,还深入探讨了有界阻塞队列的实现原理。
摘要由CSDN通过智能技术生成
线程通信概念:
线程是操作系统中独立的个体,但这些个体如果不经过特殊的处理就不能成为一个整体,线程之间的通信就成为整体的必用方式之一。当线程存在通信指挥,系统间的交互性会更强大,在提高CPU利用率的同时还会对线程任务在处理过程中进行有效的把控与监督。
为了支持多线程之间的协作,JDK提供了两个非常重要的接口线程等待wait()方法和通知notify()方法。这两个方法并不是在Thread类中的,而是输出Object类。这也意味着任何对象都可以调用这2个方法。

我们先看一个简单的例子:

public class ListAdd1 {
    private volatile static List list = new ArrayList();
    public void add(){
        list.add("jianzh5");
    }
    public int size(){
        return list.size();
    }

    public static void main(String[] args) {
        final ListAdd1 list1 = new ListAdd1();
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for(int i = 0; i <10; i++){
                        list1.add();
                        System.out.println("当前线程:" + Thread.currentThread().getName() + "添加了一个元素..");
                        Thread.sleep(500);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t1");

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    if(list1.size() == 5){
                        System.out.println("当前线程收到通知:" + Thread.currentThread().getName() + " list size = 5 线程停止..");
                        throw new RuntimeException();
                    }
                }
            }
        }, "t2");
        t1.start();
        t2.start();
    }
}
代码很简单,这是在没使用JDK线程协作时的做法。线程t2一直在死循环,当list的size等于5时退出t2,t1则继续运行。
这样其实也可以是说线程之间的协作,但是问题就是t2会一直循环运行,浪费了CPU资源(PS:list必须使用关键字volatile修饰)。

我们再看使用wait和notify时的代码:

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

    public void add(){
        list.add("jianzh5");
    }
    public int size(){
        return list.size();
    }

    public static void main(String[] args) {

        final ListAdd2 list2 = new ListAdd2();
        final byte[] lock = new byte[0];
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    synchronized (lock) {
                        System.out.println("t1启动..");
                        for(int i = 0; i <10; i++){
                            list2.add();
                            System.out.println("当前线程:" + Thread.currentThread().getName() + "添加了一个元素..");
                            Thread.sleep(500);
                            if(list2.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) {
                    System.out.println("t2启动..");
                    if(list2.size() != 5){
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("当前线程:" + Thread.currentThread().getName() + "收到通知线程停止..");
                    throw new RuntimeException();
                }
            }
        }, "t2");
        t2.start();
        t1.start();
    }
}
这里首先创建了一个的byte[]对象lock,然后线程t1,t2使用synchronzied关键字同步lock对象。线程t1一直往list添加元素,当元素大小等于5的时候调用lock.notify()方法通知lock对象。线程t2在size不等于5的时候一直处于等待状态。
这里使用byte[0]数组是因为JVM创建byte[0]所占用的空间比普通的object对象小,而花费的代价也最小。
运行结果如下:
t2启动..
t1启动..
当前线程:t1添加了一个元素..
当前线程:t1添加了一个元素..
当前线程:t1添加了一个元素..
当前线程:t1添加了一个元素..
当前线程:t1添加了一个元素..
已经发出通知..
当前线程:t1添加了一个元素..
当前线程:t1添加了一个元素..
当前线程:t1添加了一个元素..
当前线程:t1添加了一个元素..
当前线程:t1添加了一个元素..
当前线程:t2收到通知线程停止..
Exception in thread "t2" java.lang.RuntimeException
	at com.bjsxt.base.conn008.Abc$2.run(Abc.java:68)
	at java.lang.Thread.run(Thread.java:745)
看到这里可能会有疑问,为什么t1通知了t2线程运行而结果却是t1先运行完后t2再运行。
说明如下:
1、wait() 和 notify()必须配合synchrozied关键字使用,无论是wait()还是notify()都需要首先获取目标对象的一个监听器。
2、wait()释放锁,而notify()不释放锁。

线程t2一开始处于wait状态,这时候释放了锁所以t1可以一直执行,而t1在notify的时候并不会释放锁,所以t1还会继续运行。 


知识拓展

现在我们来探讨一下有界阻塞队列的实现原理并模拟一下它的实现 :

1、有界队列顾名思义是有容器大小限制的
2、当调用put()方法时,如果此时容器的长度等于限定的最大长度,那么该方法需要阻塞直到队列可以有空间容纳下添加的元素
3、当调用take()方法时,如果此时容器的长度等于最小长度0,那么该方法需要阻塞直到队列中有了元素能够取出
4、put() 和 take()方法是需要协作的,能够及时通知状态进行插入和移除操作

根据以上阻塞队列的几个属性,我们可以使用wait 和notify实现以下它的实现原理:

/**
 * 自定义大小的阻塞容器
 */
public class MyQueue {
    //1、初始化容器
    private final LinkedList<Object> list = new LinkedList<>();
    //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();

    //6、阻塞增加方法
    public void put(Object obj) {
        synchronized (lock) {
            while (count.get() == this.maxSize) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //加入元素 计数器累加 唤醒取数线程可以取数
            list.add(obj);
            count.incrementAndGet();
            lock.notify();
            System.out.println("新增的元素:" + obj);
        }
    }

    public Object take() {
        Object result = null;
        synchronized (lock) {
            while (count.get() == this.minSize) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //移除元素 计数器递减 唤醒添加的线程可以添加元素
            result = list.removeFirst();
            count.decrementAndGet();
            lock.notify();
        }
        return result;
    }

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

    public static void main(String[] args) {
        final MyQueue myQueue = new MyQueue(5);
        myQueue.put("a");
        myQueue.put("b");
        myQueue.put("c");
        myQueue.put("d");
        myQueue.put("e");

        System.out.println("当前队列长度:" + myQueue.getSize());
        Thread t1 = new Thread(new Runnable() {
            @Override public void run() {
                myQueue.put("f");
                myQueue.put("g");
            }
        }, "t1");

        t1.start();

        Thread t2 = new Thread(new Runnable() {
            @Override public void run() {
                Object obj = myQueue.take();
                System.out.println("移除的元素为:"+obj);
                Object obj2 = myQueue.take();
                System.out.println("移除的元素为:"+obj2);
            }
        },"t2");

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        t2.start();
    }
}
实现过程如下:
1、通过构造器初始化指定容器的大小。
2、程序内部有一个AtomicInteger的计数器,当调用put()操作时此计数器加1;当调用take()方法时此计数器减1。
3、在进行相应的take()和put()方法时会使用while判断进行阻塞,会一直处于wait状态,并在可以进行操作的时候唤醒另外一个线程可以进行相应的操作。

4、将此代码运行可以看到相应的效果。


<think>嗯,用户这次问的是关于notify线程是否会像wait线程一样阻塞。我需要先回顾一下条件变量线程同步的基本概念。之前的对话已经讨论了wait方法带条件的情况,现在用户可能是在进一步理解通知机制。 首先,用户可能对notify的工作方式不太清楚,或者混淆了waitnotify的行为。需要明确,调用notify线程是否会阻塞自己,这取决于具体的实现锁的状态。比如,在C++中,notify_one或notify_all通常是在持有锁的情况下调用的,但通知操作本身不会阻塞线程。不过,释放锁之后,其他线程才能被唤醒。 接下来,用户可能没有意识到notify锁的关系。当线程调用notify时,它可能仍然持有互斥锁,这时候被唤醒的wait线程需要重新获取锁才能继续执行。所以,notify线程在调用notify之后,如果释放了锁,那它本身并不会阻塞,而是继续执行后续代码。 另外,用户可能担心notify会不会导致通知线程挂起,或者需要等待通知线程执行完毕。这时候需要解释,notify只是一个信号机制,不会阻塞调用线程。而wait线程的唤醒继续执行则依赖于锁的获取,这可能会影响它们的执行顺序,但通知线程本身不会被阻塞。 还需要考虑用户的实际应用场景。比如,是否在多线程环境中正确使用锁条件变量,是否存在竞态条件或死锁的风险。用户可能在实际编码中遇到问题,比如通知丢失或线程未被及时唤醒,需要确保他们在调用notify时持有正确的锁,并且条件变量的使用符合规范。 最后,总结回答时要结构清晰,分点说明,确保用户理解notify的非阻塞特性,以及正确使用条件变量的要点。同时,给出示例代码常见误区,帮助用户巩固理解,避免常见的错误。</think>--- ### **1. 核心结论** **不会**。调用`notify`(如`notify_one`或`notify_all`)的线程**不会因发送通知而阻塞**。它的行为是**非阻塞**的——通知发出后,线程会**立即继续执行后续代码**,无需等待被唤醒的`wait`线程完成操作。 --- ### **2. 详细机制分析** #### **(1)`notify`的本质** - **仅发送信号**:`notify`的作用是**唤醒正在`wait`的线程**(一个或全部),但它本身**不涉及任何等待或阻塞逻辑**。 - **无锁释放要求**:`notify`可以在**持有锁时调用**(通常建议如此,避免竞态条件),但即使不持有锁也能调用(尽管可能导致通知丢失)。 #### **(2)`wait`与`notify`的协作流程** 以典型的生产者-消费者模型为例: | 步骤 | 生产者线程(`notify`方) | 消费者线程(`wait`方) | |------|--------------------------|------------------------| | 1 | 获取锁(`lock`) | 获取锁(`lock`) | | 2 | 修改共享数据(如填充队列) | 检查条件(如队列是否为空)| | 3 | 调用`notify_one()` | 条件不满足,调用`wait()`进入阻塞 | | 4 | **释放锁**(`unlock`) | **释放锁**并阻塞,等待唤醒 | | 5 | **继续执行后续代码** | 被唤醒后重新获取锁,检查条件 | - **关键点**:生产者调用`notify_one()`后,立即释放锁并继续执行,**不等待消费者实际被唤醒或完成消费**。 --- ### **3. 示例场景** #### **生产者线程通知方)** ```cpp std::mutex mtx; std::condition_variable cv; std::queue<int> data_queue; void producer() { std::unique_lock<std::mutex> lock(mtx); data_queue.push(42); // 修改共享数据 cv.notify_one(); // 发送通知(非阻塞) std::cout << "通知已发送,生产者继续执行..." << std::endl; // 锁在作用域结束时自动释放 } ``` #### **消费者线程等待方)** ```cpp void consumer() { std::unique_lock<std::mutex> lock(mtx); cv.wait(lock, [&] { return !data_queue.empty(); }); // 等待队列非空 auto data = data_queue.front(); data_queue.pop(); std::cout << "消费者收到数据: " << data << std::endl; } ``` #### **输出结果** ``` 通知已发送,生产者继续执行... 消费者收到数据: 42 ``` - 生产者发送通知后**立即输出日志**,无需等待消费者完成操作。 --- ### **4. 潜在误区** #### **误区:`notify`需要等待`wait`线程完成** - **错误理解**:认为生产者调用`notify_one()`后,必须等待消费者处理完数据才能继续执行。 - **实际情况**:生产者发送通知后**立即继续执行**,消费者的唤醒操作是**异步**的。若生产者后续仍需操作共享数据(如继续生产),需通过锁或其他机制保证同步。 #### **误区:`notify`必须在持有锁时调用** - **允许但不强制**:`notify`可以在无锁时调用,但通常建议**在持有锁时调用**,原因如下: 1. **避免通知丢失**:若先释放锁再调用`notify`,其他线程可能在间隙中修改条件,导致被唤醒的线程重新进入等待。 2. **保证原子性**:修改共享数据与发送通知的原子性,确保被唤醒的线程看到最新的状态。 --- ### **5. `notify`与`wait`的时序关系** - **通知可能“无效”**:若没有线程在`wait`时调用`notify`,通知会被**直接丢弃**(不会累积或延迟生效)。 - **虚假唤醒**:即使没有`notify`,`wait`也可能因系统原因被唤醒,因此必须通过**循环检查条件**来容错(例如C++中的`cv.wait(lock, predicate)`)。 --- ### **6. 总结** - **`notify`线程不阻塞**:通知是异步的,发送后立即继续执行。 - **`wait`线程依赖锁**:被唤醒后需重新获取锁才能继续操作共享数据。 - **正确实践**:在持有锁时调用`notify`,并确保条件检查的原子性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

二一点

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值