java - 单例类和volatile变量的组合

Question

据我所知，volatile 变量将始终从主内存中读取和写入。然后我想到了Singleton类。这是我的程序是这样的:
1.单例类

public class Singleton {
    private static Singleton sin;
    private static volatile int count;
    static{
        sin = new Singleton();
        count = 0;
    }
    private Singleton(){

    }
    public static Singleton getInstance(){
        return sin;
    }

    public String test(){
        count++;
        return ("Counted increased!" + count);
    }

}

2.主类

public class Java {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Derived d1 = new Derived("d1");
        d1.start();
        Derived d2 = new Derived("d2");
        d2.start();
        Derived d3 = new Derived("d3");
        d3.start();

    }
;

}

class Derived extends Thread {

    String name;
    public Derived(String name){
        this.name = name;
    }
    public void run() {
        Singleton a = Singleton.getInstance();
        for (int i = 0; i < 10; i++) {
            System.out.println("Current thread: "+ name + a.test());
        }
    }
}

我知道这可能是一个愚蠢的问题，但我不擅长 Java 中的多线程，因此这个问题让我很困惑。我认为 Singleton 类中的 static volatile int count 变量将始终具有最新值，但显然它没有......
有人能帮我理解一下吗？
非常感谢。

Answer 1

问题是volatile与线程同步无关。即使从 static volatile int count 读取确实总是返回最新值，多个线程也可能将相同的新值写回它。

考虑这个有两个线程的场景:

count is initialized zero
Thread A reads count, sees zero
Thread B reads count, sees zero
Thread A advances count to 1, stores 1
Thread B advances count to 1, stores 1
Thread A writes "Counted increased! 1"
Thread B writes "Counted increased! 1"

两个线程都读取了最新的值，但是由于 ++ 不是原子操作，一旦读取完成，每个线程都是独立的。两个线程独立计算下一个值，然后将其存储回 count 变量。最终效果是变量被递增一次，即使两个线程都执行了递增。

如果您想从多个线程递增 int，请使用 AtomicInteger .