概述
在做多线程并发处理时，常常须要对资源进行可见性訪问和相互排斥同步操作。有时候，我们可能从前辈那里得知我们须要对资源进行 volatile 或是 synchronized 关键字修饰处理。但是，我们却不知道这两者之间的差别。我们无法分辨在什么时候应该使用哪一个关键字。
本文就针对这个问题，展开讨论。
版权说明
著作权归作者全部。
商业转载请联系作者获得授权，非商业转载请注明出处。
本文作者：Coding-Naga
发表日期： 2016年4月5日
本文链接：http://blog.csdn.net/lemon_tree12138/article/details/51062421
来源：CSDN
很多其它内容：分类 >> 并发与多线程
内存语义分析
happens-before 模型简单介绍
假设你单从字面上的意思来理解 happens-before 模型，你可能会认为这是在说某一个操作在还有一个操作之前运行。只是。学习完 happens-before 之后，你就不会还这样理解了。以下是《Java 并发编程的艺术》书上对 happens-before 的定义：
在 JMM(Java Memory Model) 中。假设一个操作运行的结果须要对还有一个操作可见，那么这两个操作之间必须存在 happens-before 关系。这里提到的两个操作既能够在一个线程之内，也能够是在不同的线程之间。
volatile 的内存语义
对于多线程编程来说，每一个线程是能够拥有共享内存中变量的一个拷贝。这一点在后面还是会讲到，这里就不作过多说明。
假设一个变量被 volatile 关键字修饰时，那么对这的变量的写是将本地内存中的拷贝刷新到共享内存中；对这个变量的读会有一些不同，读的时候是无视他的本地内存的拷贝的。仅仅是从共享变量中去读取数据。
synchronized 的内存语义
我们说 synchronized 实际上是对变量进行加锁处理。
那么无论是读也好，写也好都是基于对这个变量的加锁操作。假设一个变量被 synchronized 关键字修饰，那么对这的变量的写是将本地内存中的拷贝刷新到共享内存中；对这个变量的读就是将共享内存中的值刷新到本地内存，再从本地内存中读取数据。由于全过程中变量是加锁的。其它线程无法对这个变量进行读写操作。所以能够理解成对这个变量的不论什么操作具有原子性。即线程是安全的。
实例论证
上面的一些说明或是定义可能会有一些乏味枯燥，也不太好理解。这里我们就列举一些样例来说明，这样比較详细和形象一些。
volatile 可见性測试
RunThread.java
public class RunThread extends Thread {
private boolean isRunning = true;
public boolean isRunning() {
return isRunning;
}
public void setRunFlag(boolean flag) {
isRunning = flag;
}
@Override
public void run() {
System.out.println("I'm come in...");
boolean first = true;
while(isRunning) {
if (first) {
System.out.println("I'm in while...");
first = false;
}
}
System.out.println("I'll go out.");
}
}MyRun.java
public class MyRun {
public static void main(String[] args) throws InterruptedException {
RunThread thread = new RunThread();
thread.start();
Thread.sleep(100);
thread.setRunFlag(false);
System.out.println("flag is reseted: " + thread.isRunning());
}
}对于上面的样例仅仅是一个非常普通的多线程操作，这里我们非常easy就得到了 RunThread 线程在 while 中进入了死循环。
我们能够在 main() 方法里看到一句 Thread.sleep(100) ，结合前面说到的 happens-before 内存模型，可知以下的 thread.setRunFlag(false) 并不会 happens-before 子线程中的 while 。
这样一来，尽管主线程中对 isRunning 进行了改动。然而对子线程中的 while 来说。并没有改变，所以这就会引发在 while 中的死循环。
在这样的情况下，线程工作时的内存模型像以下这样
在这里。可能你会奇怪。为什么会有两个“内存块”？这是出于多线程的性能考虑的。
尽管对象以及成员变量分配的内存是在共享内存中的，只是对于每一个线程而言，还是能够拥有这个对象的拷贝，这样做的目的是为了加快程序的运行，这也是现代多核处理器的一个显著特征。从上面的内存模型能够看出。Java的线程是直接与它自身的工作内存（本地内存）交互，工作内存再与共享内存交互。这样就形成了一个非原子的操作。在Java里多线程的环境下非原子的操作是非常危急的。这个我们都已经知道了，由于这可能会被异步的读写操作所破坏。
这里工作内存被 while 占用，无法去更新主线程对共享内存 isRunning 变量的改动。
所以。假设我们想要打破这样的限制。能够通过 volatile 关键字来处理。通过 volatile 关键字修饰 while 的条件变量，即 isRunning。
就像以下这样改动 RunThread.java 代码：
private volatile boolean isRunning = true;这样一来， volatile 改动了 isRunning 的可见性，使得主线程的 thread.setRunFlag(false) 将会 happens-before 子线程中的 while 。
终于。使得子线程从 while 的循环中跳出，问题解决。
以下我们来看看 volatile 是怎样改动了 isRunning 的可见性的吧。
这里，由于 isRunning 被 volatile 修饰，那么当子线程想要訪问工作内存中的 inRunning 时，被强制地直接从共享内存中获取。而共享内存中的 isRunning 被主线程改动过了，已经被改动成了 false 。while 被打破。这样子线程就从 while 的循环中跳出来了。
volatile 原子性測试
volatile 确实有非常多长处，但是它却有一个致命的缺点。那就是 volatile 并非原子操作。
也就是在多线程的情况。仍然是不安全的。
可能，这个时候你会发问说。既然 volatile 保证了它在线程间的可见性。那么在什么时候改动它，怎么改动它。对于其它线程是可见的，某一个线程读到的都会是改动过的值，为什么还要说它还是不安全的呢？
我们通过一个样例来说明吧。这样更形象一些。大家看以下这样一段代码：
public class DemoNoProtected {
static class MyThread extends Thread {
static int count = 0;
private static void addCount() {
for (int i = 0; i < 100; i++) {
count++;
}
System.out.println("count = " + count);
}
@Override
public void run() {
addCount();
}
}
public static void main(String[] args) {
MyThread[] threads = new MyThread[100];
for (int i = 0; i < 100; i++) {
threads[i] = new MyThread();
}
for (int i = 0; i < 100; i++) {
threads[i].start();
}
}
}count = 300
count = 300
count = 300
count = 400
... ...
count = 7618
count = 7518
count = 9918这是一个未经不论什么处理的，非常直白的过程。但是它的结果，也非常直白。事实上这个结果并不让人意外，从我们学习Java的时候，就知道Java的多线程并不安全。
是不是从上面的学习中，你感觉这个能够通过 volatile 关键字解决？既然你这么说，那么我们就来试一试。给 count 变量加入 volatile 关键字。例如以下：
public class DemoVolatile {
static class MyThread extends Thread {
static volatile int count = 0;
... ...
}
public static void main(String[] args) {
... ...
}
}count = 100
count = 300
count = 400
count = 200
... ...
count = 9852
count = 9752
count = 9652
... ...
count = 8154
count = 8054不知道这个结果是不是会让你感觉到意外。
对于 count 的混乱的数字倒是好理解一些，应该多个线程同一时候改动时就发生这样的事情。但是我们在结果为根本找不到逻辑上的最大值“10000”。这就有一些奇怪了。
由于从逻辑上来说， volatile改动了 count 的可见性。对于线程 A 来说。它是可见线程 B 对 count 的改动的。
仅仅是从结果中并没有体现这一点。
我们说，volatile并没有保证线程安全。在上面子线程中的 addCount() 方法里，运行的是 count++ 这样一句代码。而像 count++ 这样一句代码从学习Java变量自增的第一堂课上，老师就应该强调过它的运行过程。count++ 能够类比成以下的过程：
int tmp = count;
tmp = tmp + 1;
count = tmp;可见，count++ 并非原子操作。
不论什么两个线程都有可能将上面的代码分离进行，安全性便无从谈起了。
所以，到这里我们知道了 volatile 能够改变变量在线程之间的可见性，却不能改变线程之间的同步。而同步操作则须要其它的操作来保证。
synchronized 同步測试
上面说到 volatile 不能解决线程的安全性问题，这是由于 volatile 不能构建原子操作。而在多线程编程中有一个非常方便的同步处理。就是 synchronized 关键字。以下来看看 synchronized 是怎样处理多线程同步的吧。代码例如以下：
public class DemoSynchronized {
static class MyThread extends Thread {
static int count = 0;
private synchronized static void addCount() {
for (int i = 0; i < 100; i++) {
count++;
}
System.out.println("count = " + count);
}
@Override
public void run() {
addCount();
}
}
public static void main(String[] args) {
MyThread[] threads = new MyThread[100];
for (int i = 0; i < 100; i++) {
threads[i] = new MyThread();
}
for (int i = 0; i < 100; i++) {
threads[i].start();
}
}
}count = 100
count = 200
count = 300
... ...
count = 9800
count = 9900
count = 10000通过 synchronized 我们能够非常easy就获得了理想的结果。
而关于 synchronized 关键字的内存模型能够这样来表示：
某一个线程在訪问一个被 synchronized 修饰的变量时，会对此变量的共享内存进行加锁，那么这个时候其它线程对其的訪问就会被相互排斥。
synchronized 的内部实现事实上也是锁的概念。
Ref
- 《Java多线程编程核心技术》
- 《Java并发编程的艺术》