时间长了对volatile关键字的作用和使用场景忘得差不多了

volatile关键字的作用

1. 保证可见性

   当一个变量被声明为 volatile 时，它确保了线程之间的内存可见性。这意味着对 volatile 变量的修改会立即反映到所有线程中，而不是仅仅存在于当前线程的工作内存或CPU缓存中。当一个线程修改了volatile变量的值时，其他线程可以立即看到这个新值，无需通过任何同步机制。

   这是怎么做到的呢？就是被volatile修饰的变量都要到主内存中去查(这块主要是跟JVM的内存模型有关，主存、工作内存、高速缓存)

2. 禁止指令重排序

   Java编译器和处理器为了优化性能可能会对操作进行重排序，但对volatile变量的操作不会与其他内存操作一起重新排序，即在单线程内，对volatile变量的读写前后都会插入内存屏障，确保相关指令按照程序中的顺序执行。

volatile其实就是这两个作用，保证可见性在哪个框架体现了？可以去看看ConcurrentHashMap的源码，他的数组是用volatile修饰的

transient volatile Node<K,V>[] table;

那禁止指令重排在哪里体现呢？在单例模式里面体现

单例类中为什么要使用volatile关键字

• 先来复习一下单例模式怎么写

public class DoubleLazySingLeton{

		public static volatile DoubleLazySingLeton instance;
		
		private DoubleLazySingLeton(){
				System.out.println("私有化构造器，不允许被外部调用(但是反射还是能拿到)");
				// 因为反射还是能拿得到，所以这里还是要进行处理
				if(instance == null){
						instance = new DoubleLazySingLeton();
				}
				return instance;
		}
		
		public DoubleLazySingLeton getInstance(){
				if(instance == null){
						synchronized(this){
								if(instance == null){
										instance = new DoubleLazySingLeton();
								}
						}
				}
				return instance;
		}
}

我们在学习volatile关键字的时候，发现它可以禁止指令重排序从而保证执行有序性

等价于使用它就可以保证 new DoubleLazySingLeton() 创建对象实例化过程时的顺序不变

具体volatile是如何保证的呢？这就得从volatile关键字的源码下手了，这节我们先不深究，重点是要理解new DoubleLazySingLeton()为何会出现不按顺序实例化的问题？而且为何要保证实例化的顺序性呢？这才是我们本文的重中之重，带着这两个问题我们接着往下看。

• 复习一下创建一个对象的五个步骤

好，开始思考一个问题，如下实例化有何问题？

instance = new DoubleLazySingLeton();

从表面上看，没有任何问题，但是结合双重检测模式来看，那就非常有问题了。

在单线程环境下其实是没有问题的，但是在并发环境下就出现了问题，因为 new DoubleLazySingLeton() 并不是一个原子操作

如果有接触过c语言的话，应该知道在分配内存后，需要将对象的指针指向对应被分配到内存空间，抽象成jvm的命令如下

memory = allocate(); //1：分配对象的内存空间 
initInstance(memory); //2：初始化对象 
instance = memory; //3：设置instance指向刚分配的内存地址

上面操作2依赖于操作1，但是操作3并不依赖于操作2，所以jvm可以以“优化”为目的对它们进行重排序，经过重排序后顺序假设如下：

memory = allocate(); //1：分配对象的内存空间 
instance = memory; //3：设置instance指向刚分配的内存地址（此时对象还未初始化）
ctorInstance(memory); //2：初始化对象

可以看到指令重排之后，操作 3 排在了操作 2 之前，即引用instance指向内存memory时，这段内存还没被初始化。 所以，你们发现什么问题了么？

ConcurrentHashMap中的volatile关键字

transient volatile Node<K,V>[] table;

上面我们提到了volatile关键字在ConcurrentHashMap的作用是保证可见性，那到底什么是可见性？

首先我们要知道ConcurrentHashMap是为了并发场景的线程安全问题设计的，HashMap是线程不安全的

还记得HashTable吗？HashTable就是一开始解决HashMap线程不安全而设计的一个线程安全的HashMap

• 来看一下HashTable是如何设计的

  这里只放出get()和put()方法，可以看到全是直接在方法上加synchronized的，请问这锁的对象是哪个？

  如果在方法上直接加synchronized锁的是这个方法的类.class，那也就是说HashTable，读的时候不能写，写的时候不能读

  在并发场景下性能很低很低，所以ConcurrentHashMap应运而生

		private transient Entry<?,?>[] table;

		public synchronized V get(Object key) {
        Entry<?,?> tab[] = table;
        int hash = key.hashCode();
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return (V)e.value;
            }
        }
        return null;
    }
    
    public synchronized V put(K key, V value) {
        // Make sure the value is not null
        if (value == null) {
            throw new NullPointerException();
        }
        // Makes sure the key is not already in the hashtable.
				...
    }

• 来看下ConcurrentHashMap是如何设计的

  Node<K,V> 是用的volatile修饰的

  通过源码可以看到，get()方法并没有加锁，是直接去主存中查找值的

  put()和putVal()也没有加锁，这是怎么回事呢？ConcurrentHashMap底层是通过CAS+分段锁实现的并发控制

  所以在方法这看不到synchronized这样直接把锁加在方法上面的

  即读的时候可以写，写的时候可以读，只不过存在若一致性，无法保证实时一致性

		transient volatile Node<K,V>[] table;

    public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        int h = spread(key.hashCode());
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            else if (eh < 0)
                return (p = e.find(h, key)) != null ? p.val : null;
            while ((e = e.next) != null) {
                if (e.hash == h &&
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        return null;
    }

		public V put(K key, V value) {
        return putVal(key, value, false);
    }

		final V putVal(K key, V value, boolean onlyIfAbsent) {...}

上面提到了弱一致性，什么是弱一致性，什么是实时一致性？

弱一致性：即无法保证所有线程在任意时间段拿到的数据都是绝对的最新的

实时一致性：所有线程在任意时间段拿到的数据都是绝对的最新的