volatile 知识点详解

总结：

　　1、保证可见性(JMM)

　　2、不保证原子性 (核心难点：原子类)

　　3、禁止指令重排 (核心难点：说出单例模式。说出CAS。说出CPU原语)

// 验证volatile 可见性
public class JmmDemo {
    private volatile static int num = 0; // 不加volatile，程序会一直运行
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (num==0){

            }
        }).start();
        TimeUnit.SECONDS.sleep(1L); // 睡眠一秒钟，保证进入while循环
        num = 1;
        System.out.println(Thread.currentThread().getName()+num);
    }
}

// 验证volatile 不保证原子性
public class JmmDemo2 {
    // 不用synchronized lock锁来保证原子性
    // 使用AtomicInteger原子类
    private static AtomicInteger num = new AtomicInteger();

    public static void add() {
        num.getAndIncrement(); // 相当于num++
    }

    /*
    // 验证volatile 不保证原子性
    private static  int num = 0;
    // synchronized
    public synchronized static void add() {
        num++;
    }
*/
    public static void main(String[] args) {
        // 期望 num 最终是2万
        for (int i = 0; i < 20; i++) {
            new Thread(() ->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        // 判断活着的线程
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+ num);
    }
}

// 指令重排理论
// int x = 1;  // 1
// int y = 1;  // 2
// x = x + 5;  // 3
// y = x * x;  // 4
// 可重排 1234 1324 2134 2314 3124 3214
// 4可能开头吗？ 如4312.
// 不可能  因为处理器在重排的时候也会考虑指令间的依赖性

// 尝试理解多线程下的指令重排问题：
// int x,y,a,b = 0;
// 线程A              线程B
// x = a;           y = b;
// b = 1;           a = 2;
// 理想的结果下x = 0, y = 0

// 指令重排后
// 线程A              线程B
// b = 1;           a = 2;
// x = a;           y = b;
// 重排后的结果：x = 2,y = 1

// volatile可以禁止指令重排
// 内存屏障 ：CPU指令 两个作用：
// 1、保证特定的执行顺序
// 2、保证某些变量的内存可见性

//         普通写
//         普通读
// ---------------------内存屏障，禁止上面普通写与volatile读指令重排
//         volatile读
// ---------------------内存屏障，禁止下面普通写与volatile读指令重排
//         普通写
//         普通读
// 指令重排的最经典应用 DCL单例模式   DCL双重检测锁
// 单例的思想： 构造器私有
// 单例之所以安全，是因为构造器私有的！

单例模式：

// 单例的思想： 构造器私有
// 饿汉式
public class Hungry {
    // 浪费空间
    private byte[] data = new byte[10*1024*1024];

    private Hungry(){}

    private final static Hungry HUNGRY = new Hungry();

    public static Hungry getInstance() {
        return HUNGRY;
    }
}

// 懒汉式 （基础的）
public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"__测试");
    }

    private static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

    public static void main(String[] args) {
        new Thread(() -> {
            LazyMan.getInstance();
        }).start();

        // 多线程下单例失效
        /*for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }*/
    }
}

// DCL懒汉式
public class DclLazyMan {
    
    // 防止反射破环单例
    private static boolean ahsdkhaskhdkahksh = false;
    private DclLazyMan() {
        synchronized (DclLazyMan.class){
            if (ahsdkhaskhdkahksh == false) {
                ahsdkhaskhdkahksh = true;
            } else {
                throw new RuntimeException("不要想破坏我的单例");
            }
        }
    }
    private volatile static DclLazyMan dclLazyMan;

    public static DclLazyMan getInstance() {
        if (dclLazyMan == null) {
            synchronized (DclLazyMan.class) {
                if (dclLazyMan == null) {
                    dclLazyMan = new DclLazyMan();// 这个操作是不是原子性的？ 不是
                    // java创建一个对象
                    // 1、分配内存空间
                    // 2、执行构造方法，创建对象
                    // 3、将对象指向空间

                    // A  先执行13，这个时候对象还没有完成初始化！
                    // B  发现对象为空，B线程拿到的对象就不是完整的
                }
            }
        }
        return dclLazyMan;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        /*
        // 经过构造器
        DclLazyMan dclLazyMan1 = DclLazyMan.getInstance();

        // 利用反射，不经过构造器破坏单例
        Constructor<DclLazyMan> constructor = DclLazyMan.class.getDeclaredConstructor();
        DclLazyMan dclLazyMan2 = constructor.newInstance();

        System.out.println(dclLazyMan1.hashCode());
        System.out.println(dclLazyMan2.hashCode());
        */

        Constructor<DclLazyMan> constructor = DclLazyMan.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        DclLazyMan dclLazyMan2 = constructor.newInstance();// 创建对象
        
        // 利用编译的.class文件拿到ahsdkhaskhdkahksh
        // 单例再次被破坏
        Field ahsdkhaskhdkahksh = DclLazyMan.class.getDeclaredField("ahsdkhaskhdkahksh");
        ahsdkhaskhdkahksh.setAccessible(true);
        ahsdkhaskhdkahksh.set(dclLazyMan2,false);

        System.out.println(dclLazyMan2.hashCode());

    }
}

// enum类型
public enum SingleEnum {
    INSTANCE;
    public SingleEnum getInstance(){
        return INSTANCE;
    }
}
// 至少在做一个普通的JVM时候，jdk源码没有被修改的时候，枚举就是安全的！
class Demo{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException,
            InvocationTargetException, InstantiationException, InvocationTargetException {
        
        // String.class,int.class
        // 利用jad.exe反编译.class文件，发现反编译出的.java文件中没有无参构造器
        Constructor<SingleEnum> declaredConstructor = SingleEnum.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        // throw new IllegalArgumentException("Cannot reflectively create enum objects");
        SingleEnum singleEnum1 = declaredConstructor.newInstance();
        SingleEnum singleEnum2 = declaredConstructor.newInstance();
        System.out.println(singleEnum1.hashCode());
        System.out.println(singleEnum2.hashCode());

        // 这里面没有无参构造！ JVM 才是王道！
        // "main" java.lang.NoSuchMethodException: com.coding.single.SingleEnum.<init>()
    }
}

CAS ：(Compare and swap) 比较并交换

　　缺点：

1. 循环开销很大
2. 内存操作，每次只能保证一个共享变量的原子性
3. 出现ABA问题

// CAS ：(Compare and swap) 比较并交换
public class CAS_Demo {
    public static void main(String[] args) {
        // 默认值为0
        AtomicInteger atomicInteger = new AtomicInteger(5);

        // 期望值5，改为20
        System.out.println(atomicInteger.compareAndSet(5, 20));
        System.out.println(atomicInteger.get());

        // 期望值为5，改为6
        System.out.println(atomicInteger.compareAndSet(5, 6));
        System.out.println(atomicInteger.get());
    }

//----------------------------------------------------------------

//    private static AtomicInteger num = new AtomicInteger();
//    public static void add() {
//        num.getAndIncrement(); // 相当于num++
//    }

// 以getAndIncrement()分析理解 CAS

// 源码
//    public final int getAndIncrement() {
        // unsafe 可以直接操作内存
            // this 调用的对象
            // valueOffset 当前这个对象的值内存地址偏移值
            // 1  +1
//        return unsafe.getAndAddInt(this, valueOffset, 1);
//    }
//
//    public final int getAndAddInt(Object var1, long var2, int var4) {
//        int var5; //？
//        do { // 自旋锁（就是一只判断！）
                // var5 = 获得当前对象的内存地址中的值！
                // var1 等于上面的this
                // var2 等于上面的valueOffset
//            var5 = this.getIntVolatile(var1, var2);
                // compareAndSwapInt 比较并交换
                // 比较当前的值var1 对象的var2 地址中的值是不是var5，如果是，则更新为var5+1(var4)
                // 如果是期望的值，就交换，否则就不交换
//        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
//
//        return var5;
//    }
}

原子引用----解决ABA问题

// 原子引用----解决ABA问题
// 通过增加一个版本号来解决，和乐观锁一模一样

// ABA问题描述：
// T1 将A 改为 B 再改为 A  数据已经被修改过两次
// T2 再来操作A 但是A不是当初的A了  因为数据被改过了两次
public class ABA_Demo {
    // 设置初始版本为1
    static AtomicStampedReference<Integer> asf = new AtomicStampedReference<>(100,1);

    public static void main(String[] args) {
        // 线程T1
        new Thread(() -> {
            // 获得当前版本
            int stamp = asf.getStamp();
            System.out.println("T1当前版本："+stamp);
            try {
                // 睡眠1秒 待T2拿到stamp
                TimeUnit.SECONDS.sleep(1L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 即 A 改为 B
            asf.compareAndSet(100,101,asf.getStamp(),asf.getStamp()+1);
            System.out.println("T1 当前版本："+asf.getStamp());
            System.out.println("T1 当前获得的最新值："+asf.getReference());
            // 即 B 改为 A
            asf.compareAndSet(101,100,asf.getStamp(),asf.getStamp()+1);
            System.out.println("T1 当前版本："+asf.getStamp());
            System.out.println("T1 当前获得的最新值："+asf.getReference());

        },"T1").start();

        // 线程T2
        new Thread(() -> {
            // 获得当前版本
            int stamp = asf.getStamp();
            System.out.println("T2当前版本："+stamp);
            try {
                // 睡眠2秒，待T1执行完
                TimeUnit.SECONDS.sleep(2L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 即 A 改为 B
            boolean result = asf.compareAndSet(100, 101, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName()+"是否修改成功："+result);
            System.out.println("T2 当前版本："+asf.getStamp());
            System.out.println("T2 当前获得的最新值："+asf.getReference());
        },"T2").start();
    }
}