JMM中主要是围绕并发过程中如何处理原子性，可见性和有序性三个特性来建立的。最终可以保证线程安全性，volatile和synchronized两个关键字又是我们最常碰到与最容易提到的关键字，这次放在一起来讲。

线程安全性：当多个线程访问某个类的时候，不管运行环境采用何种调度方式或这些线程如何交替执行，并且在主调代码中不需要额外的同步或协同，这个类都能表现出正确的行为，那么就称这个类是线程安全的。

原子性、可见性与有序性

首先来看一下这几个特性代表的具体含义。

原子性(Atomicity)：原子性是指，一个操作是不可中断的。即使是多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。
JDK的包中提供了专门的原子包java.util.concurrent.atomic，synchronized关键字还有Lock来让程序在并发环境下具有原子性的特点。
可见性(Visibility):可见性是指当一个线程修改了共享变量的值，其它线程能立即得知这个修改。

volatile,synchronized和final关键字能实现可见性。使用final关键字需要注意对象逃逸
有序性：如果再本线程内观察，所有操作都是有序的，如果再一个线程中观察另外一个线程，那么所有操作都是无序的。前半句是指“线程内表现为串行”，后半句是指“指令重排序”现象和“工作内存与主内存同步延迟现象”
volatile和synchronized关键字可以线程之间操作的有序性。

Volatile

一个变量定义为volatile之后，它将具有两种特性：

保证次变了对所有线程的可见性，一条线程修改了这个值，新值对其它线程是可以立即得知的。
禁止指令重排优化。

volatile变量在写操作时候，会在写操作后加上store屏障指令，将本地内存刷新到主内存。

volatile变量读操作的时候，会在读操作之前加入一条load屏障指令，从主内存中读取共享变量。

关于JMM的8大操作指令，可以查看我的上篇文章，java内存模型。

volatile变量为什么在并发下不安全？

volatile变量在各个线程的工作内存中也可以存在不一致的情况，但由于每次使用之前都要刷新，执行引擎看不到不一致的情况，因此可以认为不存在一致性问题，但是Java里面的运算并非原子操作。

假如说一个写入值操作不需要依赖依赖这个值的原先值，那么在进行写入的时候我们就不需要进行读取操作。

写入操作对原本的值的时候没有要求，那么所有线程都可以写入新的值，虽然读取到的值是相同的，每个线程的操作也是正确的，但是最终结果却是错误的。

JMM

感兴趣的可以运行如下代码:

public class VolatileTest { public static volatile int count = 0; public static final int THREAD_COUNT = 20;  public static void add(){ count++; } public static void main(String[] args) { Thread[] threads = new Thread[THREAD_COUNT]; for (int i = 0; i < THREAD_COUNT; i++) { threads[i] = new Thread(() -> { for (int j = 0; j < 1000; j++) { add(); } }); threads[i].start(); }  for (int i = 0; i < THREAD_COUNT; i++) { threads[i].join(); }  System.out.println(count); }}// 如果并发正确的话：应该是20000，但是每次运行结果都不到20000

Volatile适合做什么？

适合做标量，当一个线程对某个变量进行读写操作，而其它线程仅仅进行读操作的时候，是可以保证volatile的正确性的。如下：

volatile bool stopped;public void stop(){ stopped = true}while(!stoppped){ // 执行操作}

Synchronized

Synchronized保证了原子性，可见性与有序性，它的工作时对同步的代码块加锁，使得每次只有一个线程进入代码块，从而保证线程安全。synchronized反应到字节码层面就是monitorenter与monitorexit.

注意*：虽然synchonized关键字看起来是万能的，能保证线程安全性，但是越万能的控制往往越伴随着越大的性能影响。

Synchonzied用法

实例方法上，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；
静态方法上，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；
实例方法代码块.
静态方法代码块。

//实例方法public synchronized void add(int value){ this.count += value;} //静态方法public static synchronized void add(int value){ count += value;}//实例方法代码块public void add(int value){ synchronized(this){ this.count += value;  }}//静态方法代码块public class MyClass { public static synchronized void log1(String msg1, String msg2){ log.writeln(msg1); log.writeln(msg2); }  public static void log2(String msg1, String msg2){ synchronized(MyClass.class){ log.writeln(msg1); log.writeln(msg2);  } } }

Synchonzied案例

public class SynchronziedTest implements Runnable{ static int i = 0; static int j = 0; static SynchronziedTest instance= new SynchronziedTest();  @Override public void run() { for (int j = 0; j < 1000000; j++) { increase(); } } public synchronized void increase(){ i++; } public static void main(String[] args) throws InterruptedException { // 注意新建的线程指向的同一个实例， // 如果指向不同的实例，那么两个线程关注的锁就不是同一把锁，就会导致线程不安全 Thread t1 = new Thread(instance); Thread t2 = new Thread(instance);  //错误的用法 // Thread t3 = new Thread(new SynchronziedTest()); // Thread t4 = new Thread(new SynchronziedTest()); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(i); }}//结果为:200000

注意创建线程的时候指向同一个实例，才会锁住相同的对象。