多线程笔记5 wait notify 阻塞队列

最新推荐文章于 2024-03-12 19:33:09 发布

o,onks

最新推荐文章于 2024-03-12 19:33:09 发布

阅读量199

点赞数

本文链接：https://blog.csdn.net/rushrush1/article/details/104878573

版权

object o = new object();
o.wait();
o.notify();
o.notifyAll();
wait方法和notify（意思为 “通知”）方法均属于object。

当 A线程调用o.wait()时，A会自动放弃CPU并且从Runnable状态变成Waiting状态，o指向对象有一个等待集，A会被调入等待集中。

当B线程调用o.notify();时，会随机唤醒一个等待集上的线程，而o.notifyAll();则会唤醒全部线程，对B本身无影响。

因为以上三个方法均对对象的等待集产生了修改，所以规定在用以上方法前，必须加锁。
synchronized(o){
o.wait() //wait内部会在线程放弃CPU之前将锁解开，当被唤醒后
} // 其会再次请求锁，并执行unlock
synchronized(o){
o.notify()
}
在这里插入图片描述

import java.util.Scanner;

/*
单生产者-单消费者情况

1. 是不是线程安全的？   是否有共享，是否有修改?
2. 怎么修改成线程安全的版本？ 通过加锁解决
                              volatile 不可以解决问题
3. 生产者在队列满时等待-消费者在队列空时等待
4. 生产者需要唤醒可能在等消费者；消费者需要唤醒可能在等的生产者
*/
public class MyBlockingArrayQueue {
    int[] array = new int[10];  // 下标处的数据可能出现生产者和消费者修改同一处的情况
    int front = 0;  // 只有消费者修改 front
    int rear = 0;   // 只有生产者修改 rear
    int size = 0;   // size 是生产者消费者都会修改的

    // 生产者才会调用 put
    synchronized void put(int value) throws InterruptedException {
        // 考虑满的情况
        if (size == array.length) {
            // 队列已满
            //throw new RuntimeException("队列已满"); //满了
            wait(); //停
        }

        array[rear] = value;
        rear++;
        if (rear == array.length) {
            rear = 0;
        }
        //rear = (rear + 1) % array.length;
        size++;     // 我们需要保障的是 size++ 的原子性，所以 volatile 无法解决
        notify();
    }

    // 调用 take 的一定是消费者
    synchronized int take() throws InterruptedException {
        // 考虑空的情况
        if (size == 0) {
            // 空的
            //throw new RuntimeException("队列已空");
            wait();
        }

        int value = array[front];
        front++;
        if (front == array.length) {
            front = 0;
        }
        //front = (front + 1) % array.length;
        size--;
        notify();

        return value;
    }

    static MyBlockingArrayQueue queue = new MyBlockingArrayQueue();

    static class Producer extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 100; i++) {
                    System.out.println("准备放入 " + i);
                    queue.put(i);
                    System.out.println("放入成功");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Producer producer = new Producer();
        producer.start(); //生产者启动

        Thread.sleep(2 * 1000);

        Scanner scanner = new Scanner(System.in);//消费者手动控制
        while (true) {
            scanner.nextLine();
            System.out.println(queue.take());
        }
    }
}