Java多线程安全计数与周期性打印：共享状态与消息传递策略

class Test {
    int x = 5; // 共享变量

    void example() {
        new Thread(this::run1).start();
        new Thread(this::run2).start();
    }

    void run1() {
        try {
            Thread.sleep(1000L);
            x += 5; // 线程1修改x
            System.out.println("Incremented x!");
        } catch (InterruptedException returnImmediately) {
            Thread.currentThread().interrupt();
        }
    }

    void run2() {
        try {
            Thread.sleep(1500L);
            System.out.println("x is: " + x); // 线程2读取x
        } catch (InterruptedException returnImmediately) {
            Thread.currentThread().interrupt();
        }
    }
}

import java.util.concurrent.atomic.AtomicInteger;

class CounterExample {
    // 使用AtomicInteger替代int，确保原子性和可见性
    AtomicInteger counter = new AtomicInteger(0); 

    public void startCountingAndPrinting() {
        // 计数线程
        Thread counterThread = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    counter.incrementAndGet(); // 原子地增加计数器
                    // System.out.println("Counter incremented to: " + counter.get()); // 可选：实时打印计数器变化
                    Thread.sleep(100); // 每100毫秒增加一次
                }
            } catch (InterruptedException e) {
                System.out.println("Counter thread interrupted.");
                Thread.currentThread().interrupt();
            }
        }, "CounterThread");

        // 打印线程
        Thread printerThread = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("Current counter value: " + counter.get()); // 原子地获取计数器值
                    Thread.sleep(1000); // 每1秒打印一次
                }
            } catch (InterruptedException e) {
                System.out.println("Printer thread interrupted.");
                Thread.currentThread().interrupt();
            }
        }, "PrinterThread");

        counterThread.start();
        printerThread.start();

        // 运行一段时间后停止线程
        try {
            Thread.sleep(5000); // 运行5秒
            counterThread.interrupt();
            printerThread.interrupt();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) {
        new CounterExample().startCountingAndPrinting();
    }
}

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

class MessageBusCounterExample {
    // 使用AtomicInteger作为内部计数器，确保计数的原子性
    private AtomicInteger counter = new AtomicInteger(0);
    // 使用LinkedBlockingQueue作为消息通道，传递计数器值
    private LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10); // 有界队列

    public void start() {
        // 计数线程（生产者）
        Thread producerThread = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    int currentValue = counter.incrementAndGet();
                    // 将当前计数器的值放入队列
                    queue.put(currentValue); // 如果队列满，会阻塞
                    System.out.println("Producer added: " + currentValue + ", Queue size: " + queue.size());
                    Thread.sleep(50); // 每50毫秒增加一次计数并放入队列
                }
            } catch (InterruptedException e) {
                System.out.println("Producer thread interrupted.");
                Thread.currentThread().interrupt();
            }
        }, "ProducerThread");

        // 打印线程（消费者）
        Thread consumerThread = new Thread(() -> {
            try {
                while (!Thread.currentThread().isInterrupted()) {
                    // 从队列中取出计数器值
                    int valueToPrint = queue.take(); // 如果队列空，会阻塞
                    System.out.println("Consumer retrieved and printed: " + valueToPrint);
                    Thread.sleep(200); // 每200毫秒打印一次
                }
            } catch (InterruptedException e) {
                System.out.println("Consumer thread interrupted.");
                Thread.currentThread().interrupt();
            }
        }, "ConsumerThread");

        producerThread.start();
        consumerThread.start();

        // 运行一段时间后停止线程
        try {
            Thread.sleep(5000); // 运行5秒
            producerThread.interrupt();
            consumerThread.interrupt();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) {
        new MessageBusCounterExample().start();
    }
}