并发高级篇(一)----volatile原理分析

volatile原理分析

一、什么是 volatile

能够保证线程可见性，当一个线程修改共享变量时，能够保证对另外一个线程可见性，但是注意他不能够保证共享变量的原子性问题。

二、volatile的特性

可见性
能够保证线程可见性，当一个线程修改共享变量时，能够保证对另外一个线程可见性
顺序性
程序执行程序按照代码的先后顺序执行。
原子性
即一个操作或者多个操作 要么全部执行，要么都不执行。

三、volatile可见性

public class Test001 extends Thread {
    /**
     * lock 锁 汇编的指令 强制修改值，立马刷新主内存中 另外线程立马可见刷新主内存数据
     */
    private static volatile boolean FLAG = true;

    @Override
    public void run() {
        while (FLAG) {

        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Test001().start();
        Thread.sleep(1000);
        FLAG = false;
    }
}

四、CPU多核硬件架构剖析

CPU每次从主内存读取数据比较慢，而现代的CPU通常涉及多级缓存，CPU读主内存按照空间局部性原则加载 局部快到缓存中。

五、为什么会产生可见性的原因

• 因为我们CPU读取主内存共享变量的数据时候，效率是非常低，所以对每个CPU设置对应的高速缓存 L1、L2、L3 缓存我们共享变量主内存中的副本。
• 相当于每个CPU对应共享变量的副本，副本与副本之间可能会存在一个数据不一致性的问题。
• 比如线程线程B修改的某个副本值，线程A的副本可能不可见，导致可见性问题。

六、CPU的摩尔定律

https://baike.baidu.com/item/%E6%91%A9%E5%B0%94%E5%AE%9A%E5%BE%8B/350634?fr=aladdin
基本每隔18个月，可能CPU的性能会提高一倍。

七、JMM内存模型

Java内存模型定义的是一种抽象的概念，定义屏蔽java程序对不同的操作系统的内存访问差异。
主内存
存放我们共享变量的数据
工作内存
每个CPU对共享变量（主内存）的副本。堆+方法区
JMM八大同步规范

（1）lock(锁定)：作用于 主内存的变量，把一个变量标记为一条线程独占状态
（2）unlock(解锁)：作用于 主内存的变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
（3）read(读取)：作用于 主内存的变量，把一个变量值从主内存传输到线程的 工作内存中，以便随后的load动作使用
（4）load(载入)：作用于 工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中
（5）use(使用)：作用于 工作内存的变量，把工作内存中的一个变量值传递给执行引擎
（6）assign(赋值)：作用于 工作内存的变量，它把一个从执行引擎接收到的值赋给工作内存的变量
（7）store(存储)：作用于 工作内存的变量，把工作内存中的一个变量的值传送到 主内存中，以便随后的write的操作
（8）write(写入)：作用于 工作内存的变量，它把store操作从工作内存中的一个变量的值传送到 主内存的变量中
volatile汇编lock指令

• 将当前处理器缓存行数据立刻写入主内存中。
• 写的操作会触发总线嗅探机制，同步更新主内存的值。

八、volatile的底层实现原理

通过汇编lock前缀指令触发底层锁的机制
锁的机制两种：总线锁/MESI缓存一致性协议

主要帮助我们解决多个不同cpu之间缓存之间数据同步

1、总线锁

当一个cpu（线程）访问到我们主内存中的数据时候，往总线发出一个Lock锁的信号，其他的线程不能够对该主内存做任何操作，变为阻塞状态。该模式，存在非常大的缺陷，就是将并行的程序，变为串行，没有真正发挥出cpu多核的好处。

2、MESI协议

• M 修改 (Modified) 这行数据有效，数据被修改了，和主内存中的数据不一致，数据只存在于本Cache中。
• E 独享、互斥 (Exclusive) 这行数据有效，数据和主内存中的数据一致，数据只存在于本Cache中。
• S 共享 (Shared) 这行数据有效，数据和主内存中的数据一致，数据存在于很多Cache中。
• I 无效 (Invalid) 这行数据无效

白话文：

• M:如果当前cpu副本数据如果与主内存中的数据不一致的情况下，则当前cpu状态为M
• E：独享：当只有一个cpu线程的情况下，cpu副本数据与主内存数据如果保持一致的情况下，则该cpu状态为E状态 独享。
• S：共享：在多个cpu线程的情况了下，每个cpu副本之间数据如果保持一致的情况下，则当前cpu状态为S
• I: 总线嗅探机制发现 状态为m的情况下，则会将该cpu改为i状态 无效(该cpu缓存主动获取主内存的数据同步更新)。

总线：维护解决cpu高速缓存副本数据之间一致性问题。

如果状态是M的情况下，则使用嗅探机制通知其他的CPU工作内存副本状态为I无效状态，则 刷新主内存数据到本地中，从而多核cpu数据的一致性。

3、为什么volatile不能保证原子性

public class VolatileAtomThread extends Thread {

    private static volatile int count;

    public static void create() {
        count++;
    }

    public static void main(String[] args) {
        ArrayList<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Thread tempThread = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    create();
                }
            });
            threads.add(tempThread);
            tempThread.start();
        }
        threads.forEach(thread -> {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(count);

    }
}

volatile为了能够保证数据的可见性，但是不能够保证原子性，及时的将工作内存的数据刷新主内存中，导致其他的工作内存的数据变为无效状态，其他工作内存做的count++操作等于就是无效丢失了，这是为什么我们加上volatile count结果在小于10000以内。

4、volatile存在的伪共享的问题

• Cpu会以缓存行的形式读取主内存中数据，缓存行的大小为2的幂次数字节，一般的情况下是为64个字节。
• 如果该变量共享到同一个缓存行，就会影响到整理性能。
  例如：线程1修改了long类型变量A，long类型定义变量占用8个字节，在由于缓存一致性协议，线程2的变量A副本会失效，线程2在读取主内存中的数据的时候，以缓存行的形式读取，无意间将主内存中的共享变量B也读取到内存中，而主内存中的变量B没有发生变化。

public class FalseShareTest implements Runnable {
    // 定义4和线程
    public static int NUM_THREADS = 4;
    // 递增+1
    public final static long ITERATIONS = 500L * 1000L * 1000L;
    private final int arrayIndex;
    // 定义一个 VolatileLong数组
    private static VolatileLong[] longs;
    // 计算时间
    public static long SUM_TIME = 0l;

    public FalseShareTest(final int arrayIndex) {
        this.arrayIndex = arrayIndex;
    }

    public static void main(final String[] args) throws Exception {
        for (int j = 0; j < 10; j++) {
            System.out.println(j);
            if (args.length == 1) {
                NUM_THREADS = Integer.parseInt(args[0]);
            }
            longs = new VolatileLong[NUM_THREADS];
            for (int i = 0; i < longs.length; i++) {
                longs[i] = new VolatileLong();
            }
            final long start = System.nanoTime();
            runTest();
            final long end = System.nanoTime();
            SUM_TIME += end - start;
        }
        System.out.println("平均耗时：" + SUM_TIME / 10);
    }

    private static void runTest() throws InterruptedException {
        Thread[] threads = new Thread[NUM_THREADS];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(new FalseShareTest(i));
        }
        for (Thread t : threads) {
            t.start();
        }
        for (Thread t : threads) {
            t.join();
        }
    }

    public void run() {
        long i = ITERATIONS + 1;
        while (0 != --i) {
            longs[arrayIndex].value = i;
        }
    }

    //    @sun.misc.Contended
    public final static class VolatileLong extends AbstractPaddingObject {
        public volatile long value = 0L;
//        public long p1, p2, p3, p4, p5, p6;
    }
}

解决缓存行解为共享问题
使用缓存行填充方案避免为共享
Jdk1.6中实现方案

public final static class VolatileLong{
    public volatile long value = 0L;
    public  long p1, p2, p3, p4, p5, p6;
}

定义p1-6 加上value 一共占用56个字节 ，在加上VolatileLong类中头占用8个字节一共就是占用64个字节。
注意：在Jdk1.7开始对该代码做优化了，会导致p1-p6无效，所以必须要写一个类单独继承。
Jdk1.7中实现方案

public final static class VolatileLong extends AbstractPaddingObject {
    public volatile long value = 0L;
    public  long p1, p2, p3, p4, p5, p6;
}
public class AbstractPaddingObject {
    public  long p1, p2, p3, p4, p5, p6;
}

@sun.misc.Contended
可以直接在类上加上该注解@sun.misc.Contended ，启动的时候需要加上该参数-XX:-RestrictContended

ConcurrentHashMap中的CounterCell

5、JMM中的重排序及内存屏障

什么是重排序
Java内存模型允许编译器和处理器对指令代码实现重排序提高运行的效率，只会对不存在的数据依赖的指令实现重排序，在单线程的情况下重排序保证最终执行的结果与程序顺序执行结果一致性。
重排序产生的原因
当我们的CPU写入缓存的时候发现缓存区正在被其他cpu站有的情况下，为了能够提高CPU处理的性能可能将后面的读缓存命令优先执行。

注意：不是随便重排序，需要遵循as-ifserial语义。
as-ifserial：不管怎么重排序（编译器和处理器为了提高并行的效率）单线程程序执行结果不会发生改变的。也就是我们编译器与处理器不会对存在数据依赖的关系操作做重排序。

CPU指令重排序优化的过程存在问题
as-ifserial 单线程程序执行结果不会发生改变的，但是在多核多线程的情况下，指令逻辑无法分辨因果关系，可能会存在一个乱序中心问题，导致程序执行结果错误。

public class ReorderThread {
    private static int a = 0, b = 0;
    private static int x = 0, y = 0;


    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        while (true) {
            i++;
            a = 0;
            b = 0;
            x = 0;
            y = 0;

            // a=1 x=b (x=0,y=1, y=0,x=1 x=0 y=0 x=1 ,y=1)
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {

                    a = 1;
                    x = b;
                }
            });
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {

                    b = 1;
                    y = a;
                }
            });
            thread1.start();
            thread2.start();
            thread1.join();
            thread2.join();
            System.out.println("第" + i + "次(" + x + "," + y + ")");
            if (x == 0 & y == 0) {0
                break;
            }
        }
    }
}

内存屏障解决重排序
处理器提供了两个内存屏蔽指令,解决以上存在的问题

1. 写内存屏障：在指令后插入Stroe Barrier
   ,能够让写入缓存中的最新数据更新写入主内存中，让其他线程可见。这种强制写入主内存，这种现实调用，Cpu就不会因为性能的考虑对指令重排序。
2. 读内存屏障：在指令前插入load Barrier ，可以让告诉缓存中的数据失效，强制 从新主内存加载数据，强制读取主内存，让cpu缓存与主内存保持一致，避免缓存导致的一致性问题。

public class ReorderThread {
    private static int a = 0, b = 0;
    private static int x = 0, y = 0;


    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        while (true) {
            i++;
            a = 0;
            b = 0;
            x = 0;
            y = 0;

            // a=1 x=b (x=0,y=1, y=0,x=1 x=0 y=0 x=1 ,y=1)
            Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {

                    a = 1;
                    x = b;
                }
            });
            Thread thread2 = new Thread(new Runnable() {
                @Override
                public void run() {

                    b = 1;
                    y = a;
                }
            });
            thread1.start();
            thread2.start();
            thread1.join();
            thread2.join();
            System.out.println("第" + i + "次(" + x + "," + y + ")");
            if (x == 0 & y == 0) {
                break;
            }
        }
    }
}

手动插入内存屏障

public class UnSafeUtils {

    public static Unsafe getUnsafe() {
        try {
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            return (Unsafe) theUnsafe.get(null);
        } catch (Exception e) {
            return null;
        }
    }

}
 Thread thread1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    a = 1;
                    //插入写内存屏障
                    try {
                        // 手动插入一个内存屏障
                        UnSafeUtils.getUnsafe().storeFence();
                    } catch (Exception e) {

                    }
                    x = b;
                }
            });

双重检验锁为什么需要加上volatile

public class Singleton03 {
    private static volatile Singleton03 singleton03;

    public static Singleton03 getInstance() {
        // 第一次检查
        if (singleton03 == null) {
            //第二次检查
            synchronized (Singleton03.class) {
                if (singleton03 == null) {
                    singleton03 = new Singleton03();
                }
            }
        }
        return singleton03;
    }

    public static void main(String[] args) {
        Singleton03 instance1 = Singleton03.getInstance();
        Singleton03 instance2 = Singleton03.getInstance();
        System.out.println(instance1==instance2);
    }
}

注意：因为我们在new操作 singleton03 = new Singleton03()，存在重排序的问题。可以采用 javap -c 查看字节码

• 分配对象的内存空间 memory=allocate();
• 调用构造函数初始化
• 将对象复制给变量
• 第二步和第三步流程存在重排序也有可能先执行我们的，将对象复制给变量，在执行调用构造函数初始化，导致另外一个线程获取到该对象不为空，但是该改造函数没有初始化， 所以就报错了。就是另外一个线程拿到的是一个不完整的对象。

6、 synchronized 与volatile存在的区别

• volatile保证线程可见性，当工作内存中副本数据无效之后，主动读取主内存中数据
• volatile可以禁止重排序的问题，底层内存屏障。
• volatile不会导致线程阻塞，不能够保证线程安全问题synchronized 会导致线程阻塞 能够保证线程安全问题。