狂神说JAVA-JUC并发编程（七）JMM Volatile 单例 CAS 原子引用 各种锁的理解

Volatile是Java虚拟机提供的轻量级同步机制
1 保证可见性 2 不保证原子性 3 禁止指令重排

JMM

JAVA内存模型，是一个概念，是不存在的东西，是一种约定
关于JMM的同步的约定：
1线程解锁的时候必须把共享变量立刻刷新回主内存（因为线程会把主存中的变量拷贝一份，线程操作的都是主存变量的拷贝，所以需要把做的更改刷新回主存）

2 线程加锁前，必须读取主存中变量的最新值到线程的工作内存中

3加锁和解锁是同一把锁

线程 工作内存 主内存

（弹幕：工作内存相当于虚拟机栈帧中的局部变量表 主存相当于堆 所有的线程都要进栈）

8种操作

read:线程从主内存读取变量值
load:把变量加载到线程的工作内存
Use:执行引擎使用变量
assign:执行引擎使用完变量，返回给主内存
write store写入存储到主内存
lock unlock加锁 解锁

有可能会出现线程B修改了值刷新回主内存，但是线程A没有取到这个最新的值

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可再分的（对于double和long类
型的变量来说，load、store、read和write操作在某些平台上允许例外）

lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量
才可以被其他线程锁定
read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便
随后的load动作使用
load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机
遇到一个需要使用到变量的值，就会使用到这个指令
assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变
量副本中
store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，
以便后续的write使用
write （写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内
存的变量中

JMM对这八种指令的使用，制定了如下规则：
不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
不允许一个线程将没有assign的数据从工作内存同步回主内存
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前，必须经过assign和load操作
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量对一个变量进行unlock操作之前，必须把此变量同步回主内存

volatile

保证可见性

下面这个程序无法停止，因为线程无法知道主线程中的变量已经改变了，所以需要volatile

package com.kuang.tvolatile;

import java.util.concurrent.TimeUnit;

public class JMMDemo {
    // 不加 volatile 程序就会死循环！
    // 加 volatile 可以保证可见性
   // private volatile static int num = 0;
    private  static int num = 0;

    public static void main(String[] args) { // main

        new Thread(()->{ // 线程 1 对主内存的变化不知道的
            while (num==0){

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        num = 1;
        System.out.println(num);

    }
}

但是如果在while循环里面添加了打印i的语句

while(num==0)
 {
  System.out.println(num);
 }

如下图，程序运行一会就停止了

这是因为子线程强制读了一遍i的值

在循环体中打印输出语句时，println方法中有synchronized同步代码块，而synchronized也能保证对变量的修改可见性，对变量num进行操作以后,num的值也会立即刷回主存

在子线程加了输出语句会导致run方法里面的循环每输出一次进行一次判断，当内存数据修改，等缓存一致性协议生效 再判断 就会退出循环

下面是println的源码

public void println(int x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

也可以给变量加volatile
加了volatile会强制保证可见性，不用考虑cpu有没有时间

private volatile static int num=0;

不保证原子性

什么叫原子性： 不可分割
线程A在执行任务的时候，是不能被打扰的，要么同时成功，要么同时失败

package juc;

/**
 * Created by 此生辽阔 on 2021/6/28 10:08
 */
public class Vdemo02 {
    private static int num=0;
    public static void add()
    {
        num++;
    }
    public static void main(String[] args) {
        for(int i=0;i<20;i++)
        {
            new Thread(()->{
                for(int j=0;j<1000;j++)
                {
                    add();
                }
            }).start();
        }

        while(Thread.activeCount()>2)//因为程序里面始终是有2个线程的，main线程和gc线程
        {
            Thread.yield();
            //Thread.yield()是在主线程中执行的，意思是还有出路GC和main之外的其他线程在跑，主线程就让出cpu不往下执行，让出然后重新竞争cpu的执行权
        }
        //理论上打印出来应该是20000
        System.out.println(Thread.currentThread().getName()+" "+num);//肯定不能直接
    }
}

Thread.yield()是在主线程中执行的，意思是还有出路GC和main之外的其他线程在跑，主线程就让出cpu不往下执行,是让出然后重新竞争cpu的执行权，有可能还是main抢到，不过这里是循环，抢到继续让出，直到只有2个线程

理论上打印出来应该是20000，但是实际上每次都不一样

解决方法
我们可以加synchronized

 public synchronized static void add()
    {
        num++;
    }

如果只是给变量加上volatile

  private volatile static int num=0;

注意++不是原子操作
不加lock和synchronized，怎么保证原子性？

我们来看看对于++,jvm底层是怎么操作的

方法1：

方法2：
在out目录下选中class文件，然后选择show byteCode，没有这个选项的话，你需要安装这个插件

方法3：

public static void add();
    Code:
       0: getstatic     #2                  // Field num:I
       3: iconst_1
       4: iadd
       5: putstatic     #2                  // Field num:I
       8: return

我们来分析一下++的字节码操作

第一步：获得 num的值
第二步： num的值加1
第三步： 写回num

在多线程操作的过程中，可能加1后的值还没来得及更新，就被另一个线程读到进行加1，也就是说，有一些线程用的是以前的值，所以整体加起来会小于20000

之所以小于理论值，是因为线程回写数据到主内存的时候，覆盖了已经被其他更快的线程执行的结果

假如num是0，就可能线程1加了1，还没写回，线程2就拿到了，此时num还是0，所以两个线程都操作了num，但是num的值是1，相当于只加了一次

对线程来讲只保证每次加之前，从主存取一下当前值
加的次数是固定的，有的线程取的是旧值，结果肯定小了

回到刚刚的问题，不加lock和synchronized，怎么保证原子性？

使用原子类解决原子性问题

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

因为原子类底层初始化的时候，将赋值给了一个volatiel属性
原子类的底层都直接和操作系统挂钩，在内存中修改值，Unsafe类是很特殊的存在

 public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

指令重排

什么是指令重排：你写的程序，并不是按照你写的那样执行的
源代码执行前，编译器会进行优化，按照它所认为的高效的方式运行
指令并行也可能会重排
内存系统也会重排

处理器在进行指令重排的时候，会考虑数据之间的依赖性

volatile 可以避免指令重排

内存屏障：是一个cpu指令，作用是
1、保证特定的操作执行顺序
2、可以保证某些变量的内存可见性

volatile标注后，编译器生成代码会不优化

volatile写前加SS屏障写后加SL屏障，读前加LL屏障，读后加LS屏障

总结

volatile可以保证可见性，不能保证原子性，由于内存屏障，可以保证避免指令重排现象产生

单例模式

说到volatile的防止指令重排，那么volatile的内存屏障在哪里使用的最多，就是单例模式了

饿汉式单例

饿汉式的问题：可能会浪费内存
饿汉式一上来就会把所有的东西加载到内存，对象就已经存在了，对象没有使用的话，可能会浪费内存

主要特点有构造函数私有，避免在外部被创建对象
提前创建好对象
提供公有的接口，返回在类内部提前创建好的对象
静态变量随着类的加载就已经实例化了，跟是否调用静态方法没有关系
饿汉式加载时就会初始化，懒汉式只有在获取单例的时候才会初始化
类加载时，成员变量会被初始化，局部变量不会

package juc.single;

/**
 * Created by 此生辽阔 on 2021/6/29 21:26
 */
public class hungry {
    private hungry(){

    }
   private final static hungry hunger=new hungry();
    public static hungry getInstance()
    {
        return hunger;
    }
}

懒汉式单例

针对饿汉式单例的浪费内存的问题，提出了懒汉式单例，要用的时候再创建对象

package juc.single;

/**
 * Created by 此生辽阔 on 2021/6/29 21:30
 */
public class LazyMan {
    private LazyMan(){

    }
    private static LazyMan lazyman;//还没有创建对象，只是声明，没有new

    public static LazyMan getInstance()
    {
      if(lazyman==null)
       {
         lazyman=new LazyMan();//如果这个对象为空，就实例化这个对象
       }
      return lazyman;
    }
}

在多个线程的情况下，懒汉式单例可能会出现安全问题，就是线程1进入了if判断，并开始构造对象，但是

public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static LazyMan lazyman;//还没有创建对象，只是声明，没有new

    public static LazyMan getInstance()
    {
      if(lazyman==null)
       {
         lazyman=new LazyMan();//如果这个对象为空，就实例化这个对象
       }
      return lazyman;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                LazyMan.getInstance();
            }).start();

        }
    }
}

可以看到，有3个线程调用了构造函数，这说明程序中现在有3个Lazyman对象，就不是单例了，所以不安全

双重锁机制

package juc.single;

/**
 * Created by 此生辽阔 on 2021/6/29 21:30
 */
public class LazyMan {
    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static LazyMan lazyman;//还没有创建对象，只是声明，没有new

    public static LazyMan getInstance()
    {
        //双重检测锁模式 DCL
        if(lazyman==null)
        {
            //如果为空，先上一层锁，锁LazyMan当前对象
            synchronized (LazyMan.class){//静态方法是类锁
              //如果synchronized直接写在方法上，所有线程都要抢锁，效率低，这个只有为空时才会抢锁
                if(lazyman==null)//在锁里面再判断一次
                {
                    lazyman=new LazyMan();//如果这个对象为空，就实例化这个对象
                }
            }
        }

      return lazyman;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
             LazyMan.getInstance();
              //  System.out.println(LazyMan.getInstance());
            }).start();

        }
    }
}

可以看到只创建了一个对象

但是还是有可能出现问题

 lazyman=new LazyMan();

创建对象的过程在极端情况下肯定是会出现问题的，因为不是原子性操作，会经历
1 分配内存空间，
2执行构造方法（初始化对象）
3把对象指向分配的空间
这3个步骤

但是可能会发生指令重排，可能会按132的顺序执行，就是先分配内存空间，然后用空对象先占用内存空间，占用之后再执行构造方法

如下图，很有可能A执行了13还没执行2，但是现在lazyman已经不是null了，如果现在进来一个B线程，外层判断不为空，那么B线程会直接返回lazyman，但lazyman实际上还没有完成构造，所以不安全（new只是把应用加上了，但是堆还没有创建完，return就会有问题）

所以要用volatile修饰防止指令重排（防止第二个线程抢先执行，抢先返回一个尚未初始化完成的引用）
所以这里是同步代码块保证了操作的原子性，volatile禁止了指令重排
指令重排的原理是为了提升CPU多段流水的效率，但并不是指令任意重排，处理器必须能正确处理指令依赖关系保障程序得出正确的执行结果

总结：synchronized保证的是if判断和new一个对象能同时成功或同时失败，但是new一个对象不是原子操作，执行13后，第二个线程认为已经new对象成功了，最上面的if判断不等于null

静态内部类

在一个类里面写一个静态的类
首先只要单例一定要先构造器私有
加载外部类时，不会加载静态内部类
线程安全且懒加载
但是静态内部类单例也是不安全的，因为反射可以破坏单例

package juc.single;

/**
 * Created by 此生辽阔 on 2021/6/29 22:15
 */
public class Holder {
    private Holder() {

    }
    public static Holder getInstance() {
        return InnerClass.HOLDER;
    }
    public static class InnerClass {
        private static final Holder HOLDER = new Holder();
    }
}

测试

package juc.single;

/**
 * Created by 此生辽阔 on 2021/6/29 22:15
 */
public class Holder {
    private Holder() {
        System.out.println(Thread.currentThread().getName()+"ok");
    }

    public static Holder getInstance() {
        return InnerClass.HOLDER;
    }

    public static class InnerClass {
        private static final Holder HOLDER = new Holder();
    }

    public static void main(String[] args) {
       for(int i=0;i<10;i++)
       {
           new Thread(()->{
               Holder.getInstance();
           }).start();
       }
    }
}

可以看到，内存中只有一个实例，就是只有一个线程进入了构造函数，我猜是因为静态类只加载一次

但是只要有反射，任何私有的都是纸老虎，我们以DCL的单例为例，来试试反射

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//             LazyMan.getInstance();
//              //  System.out.println(LazyMan.getInstance());
//            }).start();
    //    }
        LazyMan instance = LazyMan.getInstance();
//获得空参构造器
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        //无视私有构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        LazyMan lazyMan = declaredConstructor.newInstance();

        //测试两个对象是否一样
        System.out.println( instance );
        System.out.println(lazyMan);
    }

可以看到，两个对象不一样

在上面的基础上，对构造函数做如下修改

private LazyMan(){
                synchronized (LazyMan.class){

                    if(lazyman!=null)
                    {
                        throw new RuntimeException("不要试图通过反射破坏单例");
                    }
                    System.out.println(Thread.currentThread().getName()+"ok");

        }

看完整代码
相当于在DCL的基础上又在构造函数里面加了一重检测

package juc.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * Created by 此生辽阔 on 2021/6/29 21:30
 */
public class LazyMan {

    private LazyMan() {
        synchronized (LazyMan.class) {

            if (lazyman != null) {
                throw new RuntimeException("不要试图通过反射破坏单例");
            }
            System.out.println(Thread.currentThread().getName() + "ok");
        }
        //
    }

    private static volatile LazyMan lazyman;//还没有创建对象，只是声明，没有new

    public static LazyMan getInstance() {
        //双重检测锁模式 DCL
        if (lazyman == null) {
            //如果为空，先上一层锁，锁LazyMan当前对象
            synchronized (LazyMan.class) {//静态方法是类锁
                //如果synchronized直接写在方法上，所有线程都要抢锁，效率低，这个只有为空时才会抢锁
                if (lazyman == null)//在锁里面再判断一次
                {
                    lazyman = new LazyMan();//如果这个对象为空，就实例化这个对象
                }
            }
        }

        return lazyman;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//             LazyMan.getInstance();
//              //  System.out.println(LazyMan.getInstance());
//            }).start();
        //    }
        LazyMan instance = LazyMan.getInstance();
//获得空参构造器
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        //无视私有构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        LazyMan lazyMan = declaredConstructor.newInstance();

        //测试两个对象是否一样
        System.out.println(instance);
        System.out.println(lazyMan);
    }
}

现在我们不用geyInstance()去获取对象，而是直接通过反射创建两个对象

可以发现，单例又被破坏了，因为构造函数里面判断的是

 if (lazyman == null)//在锁里面再判断一次
                {
                }

但是注意，我们用反射new 的对象跟类里面的lazyman对象肯定是不一样的啊，没有调用getInstance(),类里面的lazyman就一直为空，所以单例又被破坏了

解决方法，用个标志位

private static boolean flag=false;
    private LazyMan() {
        synchronized (LazyMan.class) {

            if( flag==false)
            {
                flag=true;
            }
            else
            {
                throw new RuntimeException("不要试图通过反射破坏单例");
            }
        }
    }

来我们继续破坏单例，我们把这个flag字段给它破坏了

  Field  flag=LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        //无视私有构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        LazyMan lazyMan = declaredConstructor.newInstance();
        flag.set(lazyMan,false);//把第一个对象的flag重新改成false
        LazyMan lazyMan2 = declaredConstructor.newInstance();

        //测试两个对象是否一样
       // System.out.println(instance);
        System.out.println(lazyMan);
        System.out.println(lazyMan2);

单例又被破坏了。。。。

那怎么解决呢？我们点进去反射的newInstance()看看呢

我们可以看到，如果类是一个枚举类型的话，就会告诉你不能使用反射破坏枚举，枚举是jdk 1.5 开始出现的，自带单例模式

package juc.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

/**
 * Created by 此生辽阔 on 2021/6/29 21:30
 */
public class LazyMan {
private static boolean flag=false;
    private LazyMan() {
        synchronized (LazyMan.class) {

            if( flag==false)
            {
                flag=true;
            }
            else
            {
                throw new RuntimeException("不要试图通过反射破坏单例");
            }
        }
    }

    private static volatile LazyMan lazyman;//还没有创建对象，只是声明，没有new

    public static LazyMan getInstance() {
        //双重检测锁模式 DCL
        if (lazyman == null) {
            //如果为空，先上一层锁，锁LazyMan当前对象
            synchronized (LazyMan.class) {//静态方法是类锁
                //如果synchronized直接写在方法上，所有线程都要抢锁，效率低，这个只有为空时才会抢锁
                if (lazyman == null)//在锁里面再判断一次
                {
                    lazyman = new LazyMan();//如果这个对象为空，就实例化这个对象
                }
            }
        }
        return lazyman;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
//        for (int i = 0; i < 10; i++) {
//            new Thread(()->{
//             LazyMan.getInstance();
//              //  System.out.println(LazyMan.getInstance());
//            }).start();
        //    }
        // LazyMan instance = LazyMan.getInstance();
//获得空参构造器

        Field  flag=LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        //无视私有构造器
        declaredConstructor.setAccessible(true);
        //通过反射创建对象
        LazyMan lazyMan = declaredConstructor.newInstance();
        flag.set(lazyMan,false);//把第一个对象的flag重新改成false
        LazyMan lazyMan2 = declaredConstructor.newInstance();

        //测试两个对象是否一样
       // System.out.println(instance);
        System.out.println(lazyMan);
        System.out.println(lazyMan2);
    }
}

接下来我们用枚举实现单例

枚举单例

枚举本身也是一个类

package juc.single;

/**
 * Created by 此生辽阔 on 2021/6/30 9:49
 */
public enum EnumSingle {
    INSTANCE;
   public static EnumSingle getInstance()
   {
       return INSTANCE;
   }
}
 class Test{
     public static void main(String[] args) {
         EnumSingle  instance1=EnumSingle.INSTANCE;
         EnumSingle  instance2=EnumSingle.INSTANCE;
         EnumSingle  instance3=EnumSingle.getInstance();
         System.out.println( instance1);
         System.out.println( instance2);
         System.out.println( instance3);
     }
 }

可以看到，我们获取的始终都是一个相同的对象

我们来试试用反射破坏枚举单例

    EnumSingle  instance1=EnumSingle.INSTANCE;
//         EnumSingle  instance2=EnumSingle.INSTANCE;
//         EnumSingle  instance3=EnumSingle.getInstance();

         Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
         declaredConstructor.setAccessible(true);//先把构造器的私有权限破除，使得反射可以访问，创建对象
         EnumSingle instance2= declaredConstructor.newInstance();
         System.out.println( instance1);
         System.out.println( instance2);

下面的错误提示是枚举类没有空参的构造方法
也就是下面这句话出错了

 Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);

而正常破坏单例是应该报错不能使用反射破坏枚举

通过反编译我们可以看到，这个枚举本身也是一个class，它继承了一个枚举类
然而构造器还是孔灿的啊，说明我们还是被骗了

现在我们用jad.exe反编译试试

我们把class字节码生成java文件看看

jad -sjava EnumSingle.class

我们看看生成的java文件

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   EnumSingle.java

package juc.single;


public final class EnumSingle extends Enum
{

    public static EnumSingle[] values()
    {
        return (EnumSingle[])$VALUES.clone();
    }

    public static EnumSingle valueOf(String name)
    {
        return (EnumSingle)Enum.valueOf(juc/single/EnumSingle, name);
    }

    private EnumSingle(String s, int i)
    {
        super(s, i);
    }

    public static EnumSingle getInstance()
    {
        return INSTANCE;
    }

    public static final EnumSingle INSTANCE;
    private static final EnumSingle $VALUES[];

    static 
    {
        INSTANCE = new EnumSingle("INSTANCE", 0);
        $VALUES = (new EnumSingle[] {
            INSTANCE
        });
    }
}

可以看到，不是无参构造器哦，而是有参构造器，有一个String,一个Int

现在我们修改反射代码

 Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);

绝了，得到我们想要的结果了，抛出反射不能破坏枚举的单例异常
完整代码

package juc.single;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * Created by 此生辽阔 on 2021/6/30 9:49
 */
public enum EnumSingle {
    INSTANCE;
   public static EnumSingle getInstance()
   {
       return INSTANCE;
   }
}
 class Test{
     public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
         EnumSingle  instance1=EnumSingle.INSTANCE;
//         EnumSingle  instance2=EnumSingle.INSTANCE;
//         EnumSingle  instance3=EnumSingle.getInstance();

        // Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
         Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
         declaredConstructor.setAccessible(true);//先把构造器的私有权限破除，使得反射可以访问，创建对象
         EnumSingle instance2= declaredConstructor.newInstance();
         System.out.println( instance1);
         System.out.println( instance2);
     }
 }

CAS

什么是CAS,进大厂必须深入研究底层，修内功，操作系统 计算机网络原理

package juc.cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by 此生辽阔 on 2021/6/30 19:55
 */
public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        System.out.println(atomicInteger.compareAndSet(2020, 2021));//如果是2020就改成2021
        System.out.println(atomicInteger.get());
 //如果和期望的值相同，就更新这个值，否则就不更新
        System.out.println(atomicInteger.compareAndSet(2020, 2021));//如果是2020就改成2021
        System.out.println(atomicInteger.get());
    }
}

Java无法操作内存，但是C++可以操作内存，Java可以通过native方法调用c++从而操作内存

同时，Java可以通过unsafe类操作内存，从下图可以看到，unsafe类全是native方法

总结：CAS:比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作，如果不是，就一直循环

好处是不用切换线程状态，因为切换线程状态性能消耗比较大
缺点：
1：由于底层是自旋锁，循环会浪费时间
2：因为是底层的cpu操作，一次只能保证一个共享变量的原子性
3：ABA问题

原子引用解决ABA问题

ABA问题

B线程改变了一个变量，有把这个变量还原，那么A线程去读这个变量的时候，A线程并不知道B线程已经对这个变量做过改变

package com.kuang.cas;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASDemo {
//AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
// 正常在业务操作，这里面比较的都是一个个对象
static AtomicStampedReference<Integer> atomicStampedReference = new
AtomicStampedReference<>(1,1);
// CAS compareAndSet : 比较并交换！
public static void main(String[] args) {
new Thread(()->{
int stamp = atomicStampedReference.getStamp(); // 获得版本号
System.out.println("a1=>"+stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicStampedReference.compareAndSet(1, 2,
atomicStampedReference.getStamp(),
atomicStampedReference.getStamp() + 1);
System.out.println("a2=>"+atomicStampedReference.getStamp());
System.out.println(atomicStampedReference.compareAndSet(2, 1,
atomicStampedReference.getStamp(),
atomicStampedReference.getStamp() + 1));
System.out.println("a3=>"+atomicStampedReference.getStamp());
},"a").start();
// 乐观锁的原理相同！
new Thread(()->{
int stamp = atomicStampedReference.getStamp(); // 获得版本号
System.out.println("b1=>"+stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicStampedReference.compareAndSet(1, 6,
stamp, stamp + 1));
System.out.println("b2=>"+atomicStampedReference.getStamp());
},"b").start();注意：

各种锁的理解

公平锁、非公平锁

公平锁：不能插队，先来后到
非公平锁：可以插队，比如有些线程执行时间很短，但是也需要等待拿到锁的线程执行完，synchronized和lock默认都是非公平锁

  Lock lock=new ReentrantLock();

点进去构造函数

   /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

当给构造函数传参为true的时候，是公平锁

  /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

可重入锁

所有的锁都是可重入锁，有些地方叫做递归锁

你进入你家，拿到了大门的锁，也就自动拿到了里面小门的锁

package com.kuang.lock;

import javax.sound.midi.Soundbank;

// Synchronized
public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sms();
        },"A").start();


        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}

class Phone{

    public synchronized void sms(){
        System.out.println(Thread.currentThread().getName() + "sms");
        call(); // 这里也有锁
    }

    public synchronized void call(){
        System.out.println(Thread.currentThread().getName() + "call");
    }
}

package com.kuang.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        new Thread(()->{
            phone.sms();
        },"A").start();


        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}

class Phone2{
    Lock lock = new ReentrantLock();

    public void sms(){
        lock.lock(); // 细节问题：lock.lock(); lock.unlock(); // lock 锁必须配对，否则就会死在里面
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "sms");
            call(); // 这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            lock.unlock();
        }

    }

    public void call(){

        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

自旋锁

不断地尝试，直到成功为止

package juc.lock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * Created by 此生辽阔 on 2021/7/1 15:30
 */
public class SpinLockDemo {

    //Thread类型默认值是null
    AtomicReference<Thread>atomicReference=new AtomicReference<>();
      //大概就是加了锁就会一直循环，直到调用myUnlock解锁

    //加锁
    public void myLock(){
       //先获取当前线程
        Thread thread=Thread.currentThread();
       
        while(!atomicReference.compareAndSet(null,thread))
        {
           //自旋，利用CAS,如果 atomicReference是空，就把当前的thread丢进去，
            // atomicReference不为空就让它一直循环
        }
         System.out.println(Thread.currentThread().getName()+"==>myLock");
    }
    //解锁
    public void myUnlock()
    {
        Thread thread=Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"==>muUnlock");
        atomicReference.compareAndSet(thread,null);
    }
}

package juc.lock;

import javax.lang.model.element.VariableElement;
import java.util.concurrent.TimeUnit;

/**
 * Created by 此生辽阔 on 2021/7/1 15:41
 */
public class testSpinLock {
    public static void main(String[] args) throws InterruptedException {
        SpinLockDemo lock = new SpinLockDemo();


        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);//线程1拿到锁5秒之后再释放锁，这样线程2会一直自旋
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnlock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(1);//保证线程1先拿到锁
        new Thread(()-> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnlock();
            }
        },"T2").start();
    }

}

线程1拿到锁5秒之后再释放锁，这样线程2会一直自旋，线程1释放了锁之后，线程2才会拿到锁，并释放锁

死锁

死锁是一个互相争抢的过程，互相拥有对方需要的资源

死锁测试，排除死锁

注意两个线程的构造函数的传参顺序不一样

package juc.lock;

import java.util.concurrent.TimeUnit;

/**
 * Created by 此生辽阔 on 2021/7/1 16:14
 */
public class DeadLockTest {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA, lockB), "T1").start();
        new Thread(new MyThread(lockB, lockA), "T2").start();

    }
}
class MyThread implements Runnable{

    private String lockA;
    private String lockB;

    public MyThread(String lockA,String lockB)
    {
       this.lockA=lockA;
       this.lockB=lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "lock:" + lockA + "=>get" + lockB);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "lock:" + lockB + "=>get" + lockA);
            }
        }
    }
}

可以看到出现了死锁

jps定位进程号，查看哪一个进程出了问题

jps -l

我的用不了。。。

使用jstack进程号找到死锁问题

如何解开死锁？：就是要避免死锁产生的条件