这个问题在这里已经有答案了：

volatile关键字的用途是什么(24个答案）
5个月前关门了。
请参考以下代码。
共享.java

class Shared
{
    public volatile int i = 0;
}

创建线程.java

class CreateThread
{
    public static void main(String[] args) throws InterruptedException
    {
        Shared s = new Shared();
        MyThread t1 = new MyThread(s);
        t1.start();
        while(s.i!=7)
            System.out.println(s.i);
    }
}

神话阅读.java

class MyThread extends Thread
{
    Shared s = null;
    MyThread(Shared s)
    {
        this.s = s;
    }   
    public void run()
    {
        for(int j=0; j<15; j++)
        {
    /*      try
            {
                Thread.sleep(1000);
            }
            catch(Exception e){}*/
            s.i = s.i+1;
        //  System.out.println("New Value of s.i "+s.i);
    /*      try
            {
                Thread.sleep(1000);
            }
            catch(Exception e){}*/
        }
        System.out.println("Thread Going to Stop");
    }
}

如果不允许新线程休眠，那么主线程似乎无法找到变量s.i.的所有值，因为在本例中，我们得到以下输出。

0
15
15
15
..
..
..

如果允许新线程休眠，那么主线程似乎可以找到变量s.i.的所有值，因为在本例中，我们得到以下输出。

0
0
..
1
1
..
2
2
..
3
3
..
4
4
..
upto 6

从上面的输出可以清楚地看出，如果新线程没有进入睡眠状态，那么在线程main有机会读取它之前，新线程正在内存中多次更改s.i的值。
如果我将程序更改为：
共享.java

class Shared
{
    public /*volatile*/ boolean i = false;
}

神话阅读.java

class MyThread extends Thread
{
    Shared s = null;
    MyThread(Shared s)
    {
        this.s = s;
    }   
    public void run()
    {

            s.i = true;
            System.out.println("New Value of s.i "+s.i);
            try
            {
                Thread.sleep(10000);
            }
            catch(Exception e){}
        System.out.println("Thread Going to Stop");
    }
}

创建线程.java

class CreateThread
{
    public static void main(String[] args) throws InterruptedException
    {
        Shared s = new Shared();
        MyThread t1 = new MyThread(s);
        t1.start();
        while(s.i==false)
            System.out.println(s.i);
        System.out.println(s.i+" Main Stopped");
    }
}

输出：

C:\Users\gyan0\OneDrive\Desktop>java CreateThread
false
New Value of s.i true
true Main Stopped
Thread Going to Stop

看起来，即使数据不是易失性的，线程也可以立即获得这些数据。
以下是我的问题。
volatile关键字是否保证读取器线程读取最新的值？
如果volatile关键字通过不将数据保存在cpu寄存器而将其保存在内存中，我们会得到什么好处？你能举一个实际的例子来证明volatile的好处吗？