一、共享变量在线程间的可见性
可见性：一个线程对共享变量值的修改，能够及时的被其他线程看到。
共享变量：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量。
上面的工作内存其实是java内存模型抽象出来的概念，下面简要介绍一下java内存模型（JMM）。
java内存模型（java memory model）描述了java程序中各种变量（线程共享变量）的访问规则，以及在JVM中将变量存储到内存和从内存中读取出变量这样的底层细节。
- 所以的变量都存储在主内存中
- 每个线程都有自己独立的工作内存，里面保存该线程使用到的变量的副本（主内存该变量的一份拷贝）。如下图：
两条规定：
- 线程对共享变量的所有操作都必须在自己的工作内存中进行，不能直接从主内存中读写。
- 不同线程之间无法直接访问其他线程工作内存中的变量，线程间值的传递需要通过主内存来完成。
共享变量可见性实现的原理：
线程1对共享变量的修改要想被线程2及时看到，必须要经过如下几个步骤：
- 将工作内存1中更新过的共享变量更新到主内存中
- 将主内存中最新的共享变量的值更新到工作内存2中
二、synchronized实现可见性
JMM关于synchronized的两条规定：
- 线程解锁前，必须把共享变量的最新值刷新到主内存中
- 线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值。（加锁和解锁需要是同一把锁）
线程解锁前对共享变量的修改在下次加锁前对其他线程可见。
线程执行互斥代码的过程：
- 获得互斥锁
- 情况工作内存
- 从主内存拷贝变量的最新副本到工作内存
- 执行代码
- 将更改后的共享变量的值刷新到主内存
- 释放互斥锁
下面通过一段代码来讲解synchronized关键字，在这之前还需要明晰一些概念。
重排序：代码书写的顺序与实际执行的顺序不同，指令重排序是编译器或处理器为了提高程序性能而做的优化。
as-if-serial：无论如何重排序，程序执行的结果应该与代码顺序执行的结果一致。
重排序不会给单线程带来内存可见性问题，多线程中程序交错执行时，重排序可能会造成内存可见性的问题。
导致共享变量在线程间不可见的原因： synchronized解决方案：
- 线程的交叉执行 ------> 原子性
- 重排序结合线程交叉执行 ------> 原子性
- 共享变量更新后的值没有在工作内存与主内存间及时更新 ------> 可见性
下面的代码主要是通过给线程类不同的状态值使其执行不同的方法。两个线程分别执行不同的方法，其中会涉及到指令的重排序。可能会产生不同的结果。
package memoryVisual;
public class SynchronizedDemo {
//共享变量
private boolean ready = false;
private int result = 0;
private int number = 1;
//写操作
public void write(){
ready = true; //1.1
number = 2; //1.2
}
//读操作
public void read(){
if(ready){ //2.1
result = number*3; //2.2
}
System.out.println("result的值为：" + result);
}
//内部线程类
private class ReadWriteThread extends Thread {
//根据构造方法中传入的flag参数，确定线程执行读操作还是写操作
private boolean flag;
public ReadWriteThread(boolean flag){
this.flag = flag;
}
@Override
public void run() {
if(flag){
//构造方法中传入true，执行写操作
write();
}else{
//构造方法中传入false，执行读操作
read();
}
}
}
public static void main(String[] args) {
SynchronizedDemo synDemo = new SynchronizedDemo();
//启动线程执行写操作
synDemo .new ReadWriteThread(true).start();
// try {
// Thread.sleep(1000);
// } catch (InterruptedException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
//启动线程执行读操作
synDemo.new ReadWriteThread(false).start();
}
}
运行结果包括：1.result的值为：0 2.result的值为：6
若结果为0，则可能的运行顺序为1.2---2.1---2.2---1.1.
若结果为6，则有很多种运行顺序，各位自行分析。
需要注意的一点是，若给write和read方法加上synchronized关键字，则一定是按照先write再read的顺序执行的，即1.1,1.2一定在2.1,2.2之前执行，则结果一定为“result的值为：6”。但1.1和1.2的执行顺序可能会发生重排。
三、volatile实现可见性
volatile关键字：
- 能够保证volatile变量的可见性
- 不能保证volatile变量复合操作的可见性
- 不能保证volatile变量复合操作的原子性
对于第三点，例如代码private int number = 0；number++；就不是原子操作。因为这句代码可分为三步：1.读取number的值 2.将number的值加1 3.写入最新的number的值。
而通过synchronized（this）{
number++；
}
就可以实现原子操作。
但是即使将number的初始化语句改为private volatile int number = 0；仍然无法保证原子性。
tips：synchronized及volatile关键字都可以保证可见性，但只要synchronized可以保证原子性。
volatile关键字如何实现内存可见性：通俗的讲，volatile关键字每次被线程访问时，都强迫从主内存中重读该变量的值，而当该变量发生变化时，又会强迫线程将最新的值刷新到主内存。这样任何时刻，不同的线程总能看到该变量的最新值。
线程写volatile变量的过程：
- 改变线程工作内存中volatile变量副本的值
- 将改变后的副本的值从工作内存刷新到主内存
线程读volatile变量的过程：
- 从主内存中读取volatile变量的最新值到线程的工作内存中
- 从工作内存中读取volatile变量的副本
下面通过一段代码说明volatile不能保证原子性：
package memoryVisual;
public class VolatileDemo {
private volatile int number = 0;
public int getNumber(){
return this.number;
}
public void increase(){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
this.number++;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
final VolatileDemo volDemo = new VolatileDemo();
for(int i = 0 ; i < 500 ; i++){
new Thread(new Runnable() {
@Override
public void run() {
volDemo.increase();
}
}).start();
}
//如果还有子线程在运行，主线程就让出CPU资源，
//直到所有的子线程都运行完了，主线程再继续往下执行
while(Thread.activeCount() > 1){
Thread.yield();
}
System.out.println("number : " + volDemo.getNumber());
}
}
多次运行程序以后，结果会出现number的值小于500的情况。这是因为程序运行可能出现如下的情况：
例如number = 5，程序按照如下顺序执行：
- 线程A读取number的值
- 线程B读取number的值
- 线程B执行加一操作
- 线程B将最新的值写入内存中
- 线程A执行加一操作
- 线程A将最新的值写入内存中
此时number最终的执行结果为6，少加了1。
保证number自增操作的原子性有如下几种方案：
- 使用synchronized关键字
- 使用ReetrantLock（java.util.concurrent.locks包下）
- 使用AtomicInterger（java.util.concurrent.atomic包下）
第一种：
public void increase(){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
synchronized (this) {
this.number++;
}
}第二种：
//首先在类中初始化一个lock
private Lock lock = new ReentrantLock(); public void increase(){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
lock.lock();
try {
this.number++;
} finally {
lock.unlock();
}
}volatile的适用场合：
要在多线程中安全的使用volatile变量，必须同时满足：
- 对变量的写入操作不依赖其当前值
- 不满足：number++，count=count*5等
- 满足：boolean变量，记录温度变化的变量等。
- 该变量没有包含在具有其他变量的不变式中
- 不满足：low<up
四、synchronized和volatile比较
- volatile不需要加锁，比synchronized轻量级，不会阻塞线程。
- 从内存可见性角度看，volatile读相当于加锁，volatile写相当于解锁
- synchronized关键字既能保证原子性，又能保证可见性；而volatile关键字只能保证可见性