Java 多线程之三：volatile 与等待通知机制示例

public class VisibilityProblem {
    private static boolean flag = false; // 普通变量
 
    public static void main(String[] args) {
        Thread workerThread = new Thread(() -> {
            System.out.println("Worker thread started, waiting for flag...");
            while (!flag) {
                // 空循环，等待 flag 变为 true
            }
            System.out.println("Worker thread: Flag is now true. Exiting.");
        });
 
        Thread controllerThread = new Thread(() -> {
            try {
                // 主线程休眠 1 秒，确保 workerThread 先运行
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true; // 修改 flag 的值
            System.out.println("Controller thread: Set flag to true.");
        });
 
        workerThread.start();
        controllerThread.start();
    }
}

public class Singleton {
    private static volatile Singleton instance; // 必须使用 volatile
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new Singleton(); // 非原子操作！
                }
            }
        }
        return instance;
    }
}

public class AtomicityProblem {
    private static volatile int count = 0;
 
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                count++; // 这不是一个原子操作
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                count++; // 读-改-写三步操作
            }
        });
 
        t1.start();
        t2.start();
        t1.join();
        t2.join();
 
        System.out.println("Final count: " + count); // 结果几乎肯定不是 20000
    }
}

synchronized (lockObject) { // 1. 获取对象的锁
    while (condition is not met) { // 2. 循环检查条件
        try {
            lockObject.wait(); // 3. 条件不满足，释放锁并等待
        } catch (InterruptedException e) {
            // 处理中断异常
        }
    }
    // 4. 条件满足，执行相应的业务逻辑
    doBusiness();
}

synchronized (lockObject) { // 1. 获取对象的锁
    change condition; // 2. 改变条件
    lockObject.notifyAll(); // 3. 通知所有等待在该锁上的线程
}

public class ProducerConsumerDemo {
    // 共享资源
    private static final Queue<Integer> queue = new LinkedList<>();
    private static final int MAX_SIZE = 1; // 队列容量为1
    private static final Object lock = new Object(); // 锁对象
 
    public static void main(String[] args) {
        Producer producer = new Producer();
        Consumer consumer = new Consumer();
        producer.start();
        consumer.start();
    }
 
    // 生产者线程
    static class Producer extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (lock) {
                    // 检查条件：如果队列已满，则等待
                    while (queue.size() == MAX_SIZE) {
                        try {
                            System.out.println("Queue is full, Producer waits.");
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    // 生产数据
                    queue.offer(i);
                    System.out.println("Produced: " + i);
                    // 生产后通知消费者可以消费了
                    lock.notifyAll();
                }
                try {
                    Thread.sleep(500); // 模拟生产耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
    // 消费者线程
    static class Consumer extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (lock) {
                    // 检查条件：如果队列为空，则等待
                    while (queue.isEmpty()) {
                        try {
                            System.out.println("Queue is empty, Consumer waits.");
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    // 消费数据
                    Integer data = queue.poll();
                    System.out.println("Consumed: " + data);
                    // 消费后通知生产者可以生产了
                    lock.notifyAll();
                }
                try {
                    Thread.sleep(1000); // 模拟消费耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}