什么是volatile关键字？

       自从上一篇静态工厂方法代替构造函数方法以后，时隔两周没有再写也是因为lz身边一堆的事情，时间突然发现时间周期会非常的长，但是我不想放弃，就像马斯克在采访的时候说的那样，我不想放弃，除非我被困死。这次也是在一次机缘巧合中把volatile关键字深入了解了一下，在此仅做一次分享。

       想必学java这么多年，static、final、transient、volatile这一类关键字也是必须要修炼的手册。

       说到static，首先要记住的最重要的一点就是，类属性中被static所引用的变量，会被作为GC的root根节点。作为根节点就意味着这一类变量是基本上不会被回收的。因此，static很容易引入内存泄漏的风险。

       如果一个面试官问你解释一下关键字static，你告诉他static可以修饰属性、方法和内部类，以及修饰以后有什么效果，那么面试官基本上不会记住你这个回答，整个印象就是平庸。

       但是如果你说完以后，补充一下说道，你曾经遇到一个内存泄漏的问题，就是因为static修饰的一个Map类型的变量导致的，最后排查了堆栈信息找到了问题的所在，并且解决了这个问题。那么，面试官这个时候内心中对你的印象就会不自然的提升几分。如果更深入一点，static会将所引用的属性、方法以及内部类，与类直接产生引用关系，而非与类的实例。这就是为什么，你可以使用类名.属性、类名.方法、类名.内部类名，来直接引用一个被static所修饰的属性、方法和内部类。

       言归正传。今天的主题是volatile。

       其实这个关键字的重点就三个字。可见性

       为了弄明白可见性我们就必须先了解什么叫主存和工作内存，只有把这些概念搞明白了，你才会知道volatile的真正作用到底是什么，不过有一点要提醒你的是，volatile并不保证同步，这一点一定要记住。

JVM主内存与工作内存

      首先，jvm将内存组织为主内存和工作内存两个部分。

       主内存主要包括本地方法区和堆。每个线程都有一个工作内存，工作内存中主要包括两部分，一个是属于该线程私有的栈，另一个是对主存部分变量拷贝的寄存器（包括程序计数器PC和cpu工作的高速缓存区）。

       1.所有的变量都存储在主内存中，对于所有线程都是共享的。

       2.每条线程都有自己的工作内存，工作内存中保存的是主存中某些变量的拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存中的变量。

       3.线程之间无法直接访问对方的工作内存中的变量，线程间变量的传递均需要通过主内存来完成。

       下面来看看内存模型与java多线程之间的问题

       java的多线程并发问题最终都会反映在java的内存模型上，所谓线程安全无非是要控制多个线程对某个资源的有序访问或修改。总结java的内存模型，要解决两个主要问题：可见性和有序性。

       那么，何谓可见性？多个线程之间是不能互相传递数据通信的，它们之间的沟通只能通过共享变量来进行。java内存模型（JMM）规定了jvm有主内存，主内存是多个线程共享的。当new一个对象的时候，也是被分配在主内存中，每个线程都有自己的工作内存，工作内存存储了主存的某些对象的副本，当然线程的工作内存大小是有限制的。当线程操作某个对象时，执行顺序如下：

      （1）从主存复制变量到当前工作内存（read and load）

      （2）执行代码，改变共享变量值（use and assign）

      （3）用工作内存数据刷新主存相关内容（store and write）

       当一个共享变量在多个线程的工作内存中都有副本时，如果一个线程修改了这个共享变量，那么其他线程应该能够看到这个被修改后的值，这就是多线程的可见性问题，java中volatile解决了可见性问题，接下来看一下volatile关键字：

volatile关键字：

       volatile是java提供的一种同步手段，只不过它是轻量级的同步，为什么这么说，因为volatile只能保证多线程的内存可见性，不能保证多线程的执行有序性。而最彻底的同步要保证有序性和可见性，例如synchronized。任何被volatile修饰的变量，都不拷贝副本到工作内存，任何修改都及时写在主存。因此对于volatile修饰的变量的修改，所有线程马上就能看到，但是volatile不能保证对变量的修改是有序的。假如有这样的代码：

public class Test{
   public volatile int a;
   public void add (int count){
       a = a + count;
   }
}

       当一个Test对象被多个线程共享，a的值不一定是正确的，因为a=a+count包含了好几部操作，而此时多个线程的执行是无序的，因为没有任何机制来保证多个线程的执行有序性和原子性。volatile存在的意义是，任何线程对a的修改，都会马上被其他线程读取到，因为直接操作主存，没有线程对工作内存和主存的同步。所以，volatile的使用场景是有限的，在有限的一些情形下可以使用volatile变量代替锁。要使volatile变量提供理想的线程安全，必须同时满足下面两个条件：

1）对变量的写操作不依赖于当前值

2）该变量没有包含在具有其他变量的不变式中

public class Test{
   public volatile int a;
   public void setA(int a){
      this.a = a;
   }
}

      在没有volatile声明时，多线程环境下，a的最终值不一定是正确的，因为this.a = a;涉及到给a赋值和将a同步回主存的步骤，这个顺序可能被打乱。如果用volatile声明了，读取主存副本到工作内存和同步a到主存的步骤，相当于是一个原子操作。所以简单来说，volatile适合这种场景：一个变量被多个线程共享，线程直接给这个变量赋值。这是一种很简单的同步场景，这时候使用volatile的开销将会非常小。

       那么继续说什么是序性呢？多个线程执行时，CPU对线程的调度是随机的，我们不知道当前程序被执行到哪步就切换到了下一个线程，线程在引用变量时不能直接从主内存中引用，如果线程工作内存中没有该变量，则会从主内存中拷贝一个副本到工作内存中，这个过程为read-load，完成后线程会引用该副本，线程不能直接为主存中字段赋值，它会将值指定给工作内存中的变量副本（assign），完成后这个变量副本会同步到主存储区（store-write），至于何时同步过去，根据JVM实现系统决定。

       这里看一个最经典的例子就是银行汇款问题，一个银行账户存款100，这时一个人从该账户取10元，同时另一个人向该账户汇10元，那么余额应该还是100。那么此时可能发生这种情况，A线程负责取款，B线程负责汇款，A从主内存读到100，B从主内存读到100，A执行减10操作，并将数据刷新到主内存，这时主内存数据100-10=90，而B内存执行加10操作，并将数据刷新到主内存，最后主内存数据100+10=110，显然这是一个严重的问题，我们要保证A线程和B线程有序执行，先取款后汇款或者先汇款后取款。

这里将一个非原子操作进行分解分步说明，假设有一个共享变量x，线程Thread1执行x=x+1。从上面的描述中可以知道x=x+1并不是一个原子操作，它的执行过程如下：
1 从主存中读取变量x副本到工作内存
2 给x加1
3 将x加1后的值写回主存
如果另外一个线程b执行x=x-1，执行过程如下：
1 从主存中读取变量x副本到工作内存
2 给x减1
3 将x减1后的值写回主存
那么显然，最终的x的值是不可靠的。假设x现在为10，线程a加1，线程b减1，从表面上看，似乎最终x还是为10，但是多线
程情况下会有这种情况发生：
1：线程a从主存读取x副本到工作内存，工作内存中x值为10
2：线程b从主存读取x副本到工作内存，工作内存中x值为10
3：线程a将工作内存中x加1，工作内存中x值为11
4：线程a将x提交主存中，主存中x为11
5：线程b将工作内存中x值减1，工作内存中x值为9
6：线程b将x提交到中主存中，主存中x为9
同样，x有可能为11，每次执行的结果都是不确定的，因为线程的执行顺序是不可预见的。这是java同步问题产生的根源，synchronized关键字保证了多个线程对于同步块是互斥的，synchronized作为一种同步手段，解决java多线程的执行有序性和内存可见性，而volatile关键字只解决多线程的内存可见性问题。

来一条华丽的分割线***************************************************************************************************

       鉴于学习要有对比性，我在附上synchronized关键字的解释，这样对比着学习的话，相信效果更好。

       上面说了，java用synchronized关键字做为多线程并发环境的执行有序性的保证手段之一。当一段代码会修改共享变量，这一段代码成为互斥区或临界区，为了保证共享变量的正确性，synchronized标示了临界区。典型的用法如下：

synchronized(锁){
    临界区代码
}

      为了保证银行账户的安全，可以操作账户的方法如下：

public synchronized void add(int putMoney){
   money = money + putMoney;
}
public synchronized void minus(int getMoney){
   money = money - getMoney
}

      那么对于public synchronized void add(int putMoney)这种情况，意味着什么呢？其实这种情况，锁就是这个方法所在的对象。同理如果方法是public static synchronized void add(int putMoney)那么锁就是这个方法所在的class。

      理论上，每个对象都可以作为锁，但一个对象做为锁时，应该被多个线程共享，这样才显得有意义，在并发环境下，一个没有共享的对象作为锁是没有意义的。假如这样的代码：

public class ThreadTest{
    public void test(){
       Object lock = new Object();
       synchronized(lock){
          
       }
    }
}

       lock变量作为一个锁存在根本没有意义，因为它根本不是共享对象，每个线程进来都会执行Object lock=new Object();每个线程都有自己的lock，根本不存在锁竞争。

       每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列，就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程，当一个被线程被唤醒(notify)后，才会进入到就绪队列，等待cpu的调度。当一开始线程a第一次执行account.add方法时，jvm会检查锁对象account的就绪队列是否已经有线程在等待，如果有则表明account的锁已经被占用了，由于是第一次运行，account的就绪队列为空，所以线程a获得了锁，执行account.add方法。如果恰好在这个时候，线程b要执行account.minus方法，因为线程a已经获得了锁还没有释放，所以线程b要进入account的就绪队列，等到得到锁后才可以执行。
一个线程执行临界区代码过程如下：
1 获得同步锁
2 清空工作内存
3 从主存拷贝变量副本到工作内存
4 对这些变量计算
5 将变量从工作内存写回到主存
6 释放锁
可见，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

看到这里，恭喜你已经有了一点小小的概念对java的这两个关键字以及一些内存的基础知识......长路漫漫，我们还有无数个调试代码的夜晚要度过，加油...