【JavaSE】线程同步wait/notify && 单例模式 && 阻塞队列

synchronized (locker) {
    // 使用 while 防止 “虚假唤醒”
    while (!条件成立) {
        locker.wait(); // 🟢 这段逻辑是实现同步的关键一步，应该放在逻辑开头
    }
    // 当条件满足，才继续做事
}

public class StarvingSingleton {
    // 静态变量，存储单例对象，使用final修饰
    private static final StarvingSingleton instance = new StarvingSingleton();

    // 私有化构造方法，防止外部通过new创建对象
    private StarvingSingleton() {
    }

    // 提供获取单例成员接口
    public static StarvingSingleton getInstance() {
        return instance;
    }
}

public class LazySingleton {
    // 静态变量，存储单例对象，同时使用volatile修饰
    private static volatile LazySingleton instance = null;

    // 私有化构造方法，防止外部通过new创建对象
    private LazySingleton() {
    }

    // 提供一个公共的静态方法，返回单例对象
    public static LazySingleton getInstance() {
        // 第一次检查：提高效率
        if(instance == null) { 
            synchronized(LazySingleton.class) { 
                // 第二次检查：保证单例
                if(instance == null) { 
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

public class MyBlockingQueue {
    // 使用循环队列模拟阻塞队列
    private String[] arr;
    private int head = 0;
    private int tail = 0;
    private int size; // 有效元素个数
    private static final Object lock = new Object();

    public MyBlockingQueue(int capacity) {
        arr = new String[capacity];
    }

    public void put(String value) throws InterruptedException {
        synchronized (lock) {
            // 用 while 来判断队列是否满，看看是否要阻塞
            while(size >= arr.length) {
                lock.wait();
            }

            // 插入数据
            arr[tail] = value;
            tail = (tail + 1) % arr.length;
            size++;

            // 唤醒消费者
            lock.notify();
        }
    }

    public String take() throws InterruptedException {
        synchronized (lock) {
            // 用 while 来判断队列是否空，看看是否要阻塞
            while(size == 0) {
                lock.wait();
            }

            // 拿到数据
            String value = arr[head];
            head = (head + 1) % arr.length;
            size--;

            // 唤醒生产者
            lock.notify();
            return value;
        }
    }
}