前言

曾经有遇到过这样一个问题，有一个共享变量keepRunning=true,线程A中执行while (keepRunning)；，线程B中执行keepRunning = false;，在main函数中同时开启A，B线程，然后会发现程序会一直运行且不会退出。说白了这其实就是一个典型的可见性问题，A线程并不知道keepRunning已经被修改过了，故未将修改后的keepRunning变量的值从主内存中读取到线程缓存中来。

举例

上面的问题等价于下面的代码段：

 1/**
 2 * @author mars_jun
 3 */
 4public class NoVisibility_Demonstration extends Thread {
 5    boolean keepRunning = true;
 6
 7    public static void main(String[] args) throws InterruptedException {
 8        NoVisibility_Demonstration t = new NoVisibility_Demonstration();
 9        t.start();
10        System.out.println("start: " + t.keepRunning);
11        Thread.sleep(1000);
12        t.keepRunning = false;
13        System.out.println("end: " +t.keepRunning);
14    }
15
16    public void run() {
17        int x = 1;
18        while (keepRunning) {
19            //System.out.println("如果你不注释这一行，程序会正常停止！");
20            x++;
21
22        }
23        System.out.println("x:" + x);
24    }
25}

按上述代码直接运行，你会发现在打印完end: false之后，程序并没有正常的退出，而是在一直跑着while (keepRunning)这个死循环。但是我们尝试着将其中注释的代码System.out.println("如果你不注释这一行，程序会正常停止！");给取消掉注释，再运行一次上面的代码，就会发现程序会跑一段时间后正常退出。看到这里大家也许会感到奇怪，在进行System.out.println这个IO操作后，线程t竟然读到了主线程写入的t.keepRunning = false这个值，然后导致while循环退出了。这里就不得不去看下println这个方法的源码了。

1    public void println(String x) {
2        synchronized (this) {
3            print(x);
4            newLine();
5        }
6    }

这里我们会发现println方法是一个同步的方法。大家都知道用synchronized这个关键字修饰的方法或者代码块能保证代码串行化的执行(同一时间只能有一个线程获取执行权限)，在Doug Lea大神的Concurrent Programming in Java一书中有这样一个片段来描述synchronized这个关键字：

In essence, releasing a lock forces a flush of all writes from working memory employed by the thread, and acquiring a lock forces a (re)load of the values of accessible fields. While lock actions provide exclusion only for the operations performed within a synchronized method or block, these memory effects are defined to cover all fields used by the thread performing the action.

简单翻译一下：从本质上来说，当线程释放一个锁时会强制性的将工作内存中之前所有的写操作都刷新到主内存中去，而获取一个锁则会强制性的加载可访问到的值到线程工作内存中来。虽然锁操作只对同步方法和同步代码块这一块起到作用，但是影响的却是线程执行操作所使用的所有字段。
这也就解释了为什么加上System.out.println("如果你不注释这一行，程序会正常停止！");这句代码后，线程t能够读取到修改后的keepRunning的值了。对于这个问题上，有些人的说法是：打印是IO操作，而IO操作会引起线程的切换，线程切换会导致线程原本的缓存失效，从而也会读取到修改后的值。这里我认为这种说法也是有道理的，我尝试着将打印换成File file = new File("G://1.txt");这句代码，程序也能够正常的结束。当然，在这里大家也可以尝试将将打印替换成synchronized(NoVisibility_Demonstration.class){ }这句空同步代码块，发现程序也能够正常结束。

结论

针对上述问题，最起码可以得出一个结论：当进行IO操作或者线程内部调用synchronized修饰的方法或者同步代码块时，线程的缓存会进行刷新，也就是会感知到共享变量的变化。当然这也只是针对非volatile修饰的变量而言，当变量被申明为volatile的时候，每次使用该变量都会从主内存中进行读取。（这里对volatile不太熟悉的可以去看我的相关文章浅析volatile原理及其使用）

总结

只有在以下条件下，才能保证一个线程对字段的更改对其他线程可见：

写入线程释放同步锁，读取线程随后获取相同的同步锁。释放锁的时候会强制从线程使用的工作内存中刷新所有写入，并且在获取锁的时候会强制重新加载可访问字段的值。
如果一个字段被声明为volatile，则写入线程会立即将修改后的值同步到主内存。读取线程必须在每次访问时重新加载volatile字段的值。
线程第一次访问一个对象的某个字段时，它会看到字段的初始值或来自某个其他线程写入的值。
当一个线程终止时，所有写入的变量都被刷新到主内存。例如:现有线程A，B，在B线程中调用A.join()，那么在B中可以保证看到A线程产生的影响。

END