多线程中的Java volatile关键字

Question

我试图重现 Java 多线程中的非易失性变量行为。 在这里，我在 OccurrenceCounter.java 类中有非易失性变量 test。 在 ThreadDemo.java 类中，我有 main 产生两个线程的方法。 在thread1 中它不断检查非易失变量test 的值 在while循环中。 如果我在 MyRunnableThread1.java 中运行下面的示例，occurrenceCounter.isTest() 的值不会从 CPU 缓存中获取。

OccurrenceCounter.java：

public class OccurrenceCounter {

    // non-volatile variable
    private   boolean test=true;

    public OccurrenceCounter(boolean test)
    {
        this.test=test;
    } 

    public boolean isTest() {
        return test;
    }

    public void setTest(boolean test) {
        this.test = test;
    }
}

MyRunnableThread1.java：

// Thread 1
public class MyRunnableThread1 implements Runnable {

    private String threadName;
    private OccurrenceCounter occurrenceCounter;

    public MyRunnableThread1(String threadName,OccurrenceCounter occurrenceCounter)
    {
        this.threadName=threadName; 
        this.occurrenceCounter=occurrenceCounter;
    }

    @Override
    public void run() {

        System.out.println("Thread "+threadName + " started");
        System.out.println("value of flag:"+occurrenceCounter.isTest());

        int i=0;
        // random processing code 
        while(i<1000000000L)
        {
           i++; 
           i++;
           i++;
        }
        // checking whether non-volatile variable is taken from cpu cache
        while(occurrenceCounter.isTest())
        {

        }
    System.out.println("Thread "+threadName + " finished");
    }
}

MyRunnableThread2.java：

// Thread 2
public class MyRunnableThread2 implements Runnable {

    private String threadName;
    private OccurrenceCounter occurrenceCounter;

    public MyRunnableThread2(String threadName,OccurrenceCounter occurrenceCounter)
    {
        this.threadName=threadName; 
        this.occurrenceCounter=occurrenceCounter;
    }

    @Override
    public   void run() {

        System.out.println("Thread "+threadName + " started");

        occurrenceCounter.setTest(false);
        System.out.println("Thread "+threadName + " finished");
    }
}

ThreadDemo.java：

public class ThreadDemo {

    public static void main(final String[] arguments) throws InterruptedException {

       System.out.println("main thread started");

       OccurrenceCounter occurrenceCounter =new OccurrenceCounter(true);

       MyRunnableThread1 myRunnableThread1=new MyRunnableThread1("Thread1", occurrenceCounter);
       MyRunnableThread2 myRunnableThread2=new MyRunnableThread2("Thread2", occurrenceCounter);

       Thread t1=new Thread(myRunnableThread1);
       Thread t2=new Thread(myRunnableThread2);

       t1.start();

       try
       {
           Thread.sleep(100);
       }
       catch(Exception e)
       {
           System.out.println("main thread sleep exception:"+e);
       }

       t2.start();

       System.out.println("main thread finished");
   }
}

在 MyRunnableThread1.java 的 while 循环中，即使 OcuurenceCounter 类中的 test 变量是非易失性的，CPU 缓存也不会返回条件 occurrenceCounter.isTest()。 但是如果我删除第一个 while 循环：

while(i<1000000000L)
{
   i++; 
   i++;
   i++;
}

然后我可以看到条件occurrenceCounter.isTest() 始终为假，即使它由thread2 更新并且thread1 永远不会终止。 那么为什么会出现这个while循环：

while(i<1000000000L)
{
   i++; 
   i++;
   i++;
}

影响非易失性变量的行为？ 这是第一个while循环强制从内存而不是thread1的CPU缓存中读取值吗？我试图得到这个答案很多。但我做不到。

请任何人帮助我解决这个问题。

Answer 1

使用volatile，JMM 可以保证更新后的值可供其他线程使用。

如果没有volatile或其他同步，更新后的值可能或不能可供其他线程使用，这是不确定的。

在这种情况下，循环

while(i<1000000000L) {
    i++; 
    i++;
    i++;
}

无法保证变量test 的内存可见性，纯属巧合。不要依赖它。

Answer 2

volatile 关键字确保如果一个Thread 对该变量进行了一些更改，那么在更改后读取它的其他Threads 将看到它。如果您使用普通的非volatile 变量，那么其他Threads 可能会也可能不会看到它。这取决于 JVM 的内部结构。

那么，如何解决呢？有几种方法：

1. 如您所述，您可以将其设为volatile。这可能是最简单的方法：

   public class OccurrenceCounter {
   
       private volatile  boolean test=true;
       // ...
   }
   

2. 您可以将访问器设为synchornized。在这种情况下，您必须同步所有变量访问：

   public class OccurrenceCounter {
   
       private  boolean test=true;
   
       public OccurrenceCounter(boolean test)
       {
           this.test=test;
       } 
   
       public synchronized boolean isTest() {
           return test;
       }
   
       public synchronized void setTest(boolean test) {
           this.test = test;
       }
   }
   

3. 您可以使用AtomicBoolean 为您处理所有这些。您为此付出的代价是 API 会稍微冗长一些。除非您想使用 compareAndSet() 或 getAndSet() 方法，否则这可能有点过头了：

   private AtomicBoolean test = new AtomicBoolean(true);
   
   public OccurrenceCounter(boolean test)
   {
       this.test.set(test);
   } 
   
   public boolean isTest() {
       return test.get();
   }
   
   public void setTest(boolean test) {
       this.test.set(test);
   }