如何在内部类中检测非final整型变量的变化？

嘿，我来帮你搞定这个问题～首先先说说你用独立线程循环检测变量的方案：如果直接写while(true)空循环是不合理的，因为它会把CPU核心占满，造成不必要的资源浪费，得优化一下；然后关于内部类要求变量为final的问题，其实有不少办法绕开，同时满足你修改变量的需求，下面给你详细说：

为什么内部类要求变量是final/effectively final？ #

Java里匿名内部类访问外部变量时，会复制一份变量的副本到内部类里。如果外部变量不是final，那外部修改变量后，内部类的副本和外部变量就不一致了，会导致逻辑错误，所以Java强制要求这类变量是final或者“实际不可变”（effectively final，Java 8+支持）。但我们可以用引用类型来包装这个整型变量，这样引用本身不变，内部的数值可以修改，就满足要求了。

可行的解决方案 #

1. 使用AtomicInteger（推荐，线程安全+简洁） #

AtomicInteger是Java并发包提供的线程安全的整型包装类，它的引用可以是effectively final，同时内部数值可以自由修改，还能保证多线程下的可见性：

import java.util.concurrent.atomic.AtomicInteger;

// 初始化变量
AtomicInteger myValue = new AtomicInteger(0);

new Thread(new Runnable() {
    @Override
    public void run() {
        int lastValue = myValue.get();
        while (!Thread.currentThread().isInterrupted()) {
            int currentValue = myValue.get();
            // 检测到变量变化
            if (currentValue != lastValue) {
                yes(); // 执行你的特定操作
                lastValue = currentValue;
            }
            // 加休眠避免CPU空转，间隔可根据需求调整
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // 线程被中断时，标记中断状态并退出循环
                Thread.currentThread().interrupt();
            }
        }
    }
}).start();

// 外部修改变量的地方
myValue.set(5); // 这会触发线程里的检测逻辑

2. 自定义Holder类（灵活适配需求） #

如果不想用并发包的类，可以自己写一个简单的Holder类来包装整型变量：

// 自定义包装类
class IntHolder {
    int value;
}

// 初始化Holder
IntHolder valueHolder = new IntHolder();
valueHolder.value = 0;

new Thread(new Runnable() {
    @Override
    public void run() {
        int lastValue = valueHolder.value;
        while (!Thread.currentThread().isInterrupted()) {
            if (valueHolder.value != lastValue) {
                yes();
                lastValue = valueHolder.value;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}).start();

// 外部修改变量
valueHolder.value = 10;

3. 用Wait/Notify替代轮询（更高效） #

如果不想用轮询（哪怕加了休眠），可以用wait()和notify()机制，让线程在变量没变化时进入等待状态，变量变化时主动唤醒线程，完全不浪费CPU：

class IntHolder {
    int value;
    private final Object lock = new Object();

    // 修改变量时唤醒等待的线程
    public void setValue(int newValue) {
        synchronized (lock) {
            this.value = newValue;
            lock.notify();
        }
    }

    public int getValue() {
        synchronized (lock) {
            return value;
        }
    }
}

IntHolder holder = new IntHolder();
holder.setValue(0);

new Thread(new Runnable() {
    @Override
    public void run() {
        int lastValue = holder.getValue();
        synchronized (holder.lock) {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    // 等待变量变化的通知
                    holder.lock.wait();
                    int currentValue = holder.getValue();
                    if (currentValue != lastValue) {
                        yes();
                        lastValue = currentValue;
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        }
    }
}).start();

// 外部修改变量时自动唤醒线程
holder.setValue(3);

总结 #

• 初始的while(true)空轮询方案不合理，必须加休眠或者改用wait/notify机制，避免CPU资源浪费；
• 解决内部类不能访问非final变量的核心思路是用引用类型包装整型变量，保证引用本身不变，内部数值可修改；
• 优先推荐AtomicInteger，既保证线程安全，又简洁易用；如果追求最高效率，用wait/notify机制。

内容的提问来源于stack exchange，提问作者Vedantkarandikar