说明 volatile ：这段代码是线程安全的吗？

Question

我试图用一个例子来说明 易失性 的使用和重要性，如果省略 易失性 ，实际上不会给出好的结果。

但我不太习惯使用易失性。以下代码的想法是，如果省略 易失性，则导致无限循环，如果存在 易失性，则完全线程安全。下面的代码是线程安全的吗？您是否有任何其他使用 易失性 的实际且简短的代码示例，如果没有它，会给出明显不正确的结果？

这是代码：

public class VolatileTest implements Runnable {

    private int count;
    private volatile boolean stopped;

    @Override
    public void run() {
        while (!stopped) {
            count++;
        }
        System.out.println("Count 1 = " + count);
    }

    public void stopCounting() {
        stopped = true;
    }

    public int getCount() {
        if (!stopped) {
            throw new IllegalStateException("not stopped yet.");
        }
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileTest vt = new VolatileTest();
        Thread t = new Thread(vt);
        t.start();
        Thread.sleep(1000L);
        vt.stopCounting();
        System.out.println("Count 2 = " + vt.getCount());
    }
}

Answer 1

维克多是对的，您的代码存在问题：原子性和可见性。

这是我的版本：

    private int count;
    private volatile boolean stop;
    private volatile boolean stopped;

    @Override
    public void run() {
        while (!stop) {
            count++; // the work
        }
        stopped = true;
        System.out.println("Count 1 = " + count);
    }

    public void stopCounting() {
        stop = true;
        while(!stopped)
           ; //busy wait; ok in this example
    }

    public int getCount() {
        if (!stopped) {
            throw new IllegalStateException("not stopped yet.");
        }
        return count;
    }

}

如果一个线程观察到 stopped==true，则可以保证工作完成并且结果可见。

从易失性写入到易失性读取（在同一个变量上）存在发生之前关系，因此如果有两个线程，

   thread 1              thread 2

   action A
       |
 volatile write  
                  \
                     volatile read
                          |  
                       action B

操作 A 发生在操作 B 之前； A 中的写入对 B 可见。

Answer 2

对我来说，以令人信服的方式说明并发问题总是很困难：好吧，发生在之类的事情都很好，但为什么要关心呢？真的有问题吗？有很多很多写得很糟糕、同步很差的程序——但它们在大多数时间仍然有效。

我曾经在“大部分时间都有效 VS 有效”的言辞中寻找解决方案，但坦率地说，这是一种薄弱的方法。所以我需要的是一个能让差异变得明显的例子——而且最好是痛苦的。

所以这里有一个版本确实显示了差异：

public class VolatileExample implements Runnable {
    public static boolean flag = true; // do not try this at home

    public void run() {
        long i = 0;
        while (flag) {
            if (i++ % 10000000000L == 0)
                System.out.println("Waiting  " + System.currentTimeMillis());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new VolatileExample());
        thread.start();
        Thread.sleep(10000L);
        flag = false;
        long start = System.currentTimeMillis();
        System.out.println("stopping " + start);
        thread.join();
        long end = System.currentTimeMillis();
        System.out.println("stopped  " + end);
        System.out.println("Delay: " + ((end - start) / 1000L));
    }
}

一个简单的运行显示：

Waiting  1319229217263
stopping 1319229227263
Waiting  1319229242728
stopped  1319229242728
Delay: 15

也就是说，运行线程需要超过十秒（此处为 15 秒）才能注意到任何< /em> 改变。

使用易失性，您可以：

Waiting  1319229288280
stopping 1319229298281
stopped  1319229298281
Delay: 0

也就是说，（几乎）立即退出。 currentTimeMillis 的分辨率约为 10ms，因此差异超过 1000 倍。

请注意，它是 Apple 版本的（前）Sun JDK，带有 -server 选项。添加 10 秒等待是为了让 JIT 编译器发现循环足够热，并对其进行优化。

希望有帮助。

Answer 3

进一步简化 @Elf 示例，其中其他线程永远不会获得其他线程更新的值。删除 System.out.println 因为 println 中有同步代码，而 out 是静态的，这可以帮助其他线程获取标志变量的最新值。

public class VolatileExample implements Runnable {
   public static boolean flag = true; 


  public void run() {
     while (flag);
  }

  public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new VolatileExample());
    thread.start();
    Thread.sleep(1000L);
    flag = false;
    thread.join();
  }
}

Answer 4

为了说明 易失性 关键字在并发性方面的重要性，您所需要做的就是确保在单独的线程中修改和读取易失性字段。

Answer 5

更新 我的答案是错误的，请参阅来自reputable的答案。

---

它不是线程安全的，因为无法访问count，只有一个编写器线程。如果存在另一个写入线程，count 的值将与更新次数不一致。

通过检查 getCount 方法内的 stopped 易失性来确保 count 值对主线程的可见性。这就是并发实践书中所谓的搭载同步。

Answer 6

错误的代码，如果 y 已经是 2，我们也不能假设 x = 1：

Class Reordering {
  int x = 0, y = 0;
  public void writer() {
    x = 1;
    y = 2;
  }

  public void reader() {
    int r1 = y;
    int r2 = x;
  }
}

使用 volatile 关键字的示例：

class VolatileExample {
  int x = 0;
  volatile boolean v = false;
  public void writer() {
    x = 42;
    v = true;
  }

  public void reader() {
    if (v == true) {
      //uses x - guaranteed to see 42.
    }
  }
}

来源：http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html