每个线程内部都保有共享变量的副本，当一个线程更新了这个共享变量，另一个线程可能看的到，可能看不到，这就是可见性问题。

下面这段代码中 main 线程中 改变了 ready的值，当开启多个子线程时，子线程的值并不是马上就刷新为最新的ready的值（这里的中间刷新的时间间隔到底是多长，或者子线程的刷新机制，自己也不太清楚。当开启一个线程去执行时，ready值改变时就会立刻刷新，循环立刻就结束，但是当开启多个线程时，就会有一定的延迟）。

public class SelfTest {
    private  static boolean ready;
    private static int number;
    private static long time;

    public static class ReadThread extends Thread {
        public void run() {
            while(!ready ){
                System. out.println("*******  "+Thread.currentThread()+""+number);
                Thread. yield();
            }
            System. out.println(number+"  currentThread: "+Thread.currentThread());
        }
    }
    public static void main(String [] args) {
        time = System.currentTimeMillis();
        new ReadThread().start();
        new ReadThread().start();
        new ReadThread().start();
        new ReadThread().start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        number = 42;
        ready = true ;
        System.out.println("赋值时间：ready = true    ");
    }
}

上面这段代码的执行结果：可以看出赋值后，循环还是执行了几次。

此时如果把 ready的属性加上 volatile 结果便是如下的效果：

由此可见Volatile可以解决内存可见性的问题。

上面讲的加锁机制同样可以解决内存可见性的问题，加锁的含义不仅仅局限于互斥行为，还包括内存可见性。为了确保所有线程都能看到共享变量的最新值，所有执行读操作或者写操作的线程都必须在同一个锁上同步。

注：由于System.out.println的执行仍然需要时间，所以这面打印的顺序还是可能出现错乱。