JUC包学习与总结（三）

JUC笔记（三）

常用辅助类

1、CountDownLatch

会维护一个减法计数器，当计数器归0时，才会继续之后的操作，否则阻塞。

两个关键方法:

• countDown():计数器-1；

• await():阻塞等待计数器归0，也能够配置超时时间。

//实现例子:
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        //初始化一个计数器
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 1; i <=5 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"start count...");
                countDownLatch.countDown();
            }).start();
        }
        //等待计数器归零，归零前阻塞
        countDownLatch.await();
        //countDownLatch.await(50, TimeUnit.SECONDS); 也有超时等待方法
        System.out.println(Thread.currentThread().getName()+" end ...");

    }
}

执行结果：

2、CyclicBarrier

会维护一个加法计数器，当计数器达到设定值时，才会继续之后的操作（或者执行参数中的runnable），之前阻塞。

//实现例子:

public class CyclicBarrierTest {
    public static void main(String[] args) {
        //设定计数器最大值，当计数器值到达时执行一个方法。
        CyclicBarrier cyclicBarrier = new CyclicBarrier(10,()->{
            System.out.println("数量达到上限!程序结束");
        });
        for (int i = 1; i <=10 ; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"is in count...");
                try {
                    //等待，计数器加1
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

执行结果：

3、Semaphore 信号量

通过信号量限制最大线程数。

方法：

• acquire();获取一个信号量，总信号量-1，当信号量为0时，阻塞。

• release();释放一个信号量，总信号量+1。

JMM

Java Memory Model ->java内存模型

8大操作

线程并不会直接操作主内存，而是先将参数从主内存读取一份（read）,载入自己的工作内存（load），然后线程的 执行引擎 会使用工作内存中的值（use），操作完后将新的值赋值回工作内存（assign），再将工作内存的值取出（stroe）,刷新到主内存（write）。

操作必须（lock）和（unlock）

Volatile

volatile的理解

• 保证可见性（JMM）

  如何验证？见上图👆

• 不保证原子性（原子类）

• 禁止指令重排（有序性，单例模式，CAS ,CPU原语）

  原代码->编译器（指令重排）->指令并行重排->内存系统的重排->最终指令顺序

  单线程也无法避免指令重排

  如何验证？

  volatile如何禁止指令重排？

  内存屏障（Memory Barrier）：CPU的指令

  有两个作用：

  1. 保证特定的执行顺序

     会在volatile读的前后增加两道内存屏障（不可见），会禁止前/后的指令跟volatile读指令进行指令重排。

  2. 保证某些变量的内存可见性

单例模式-指令重排的最经典实现

单例模式的终极思想：构造器私有！

饿汉式

//饿汉式
//先new好对象，但是占空间，不建议使用
public class Hungry {
    private Hungry(){}

    private static Hungry h = new Hungry();
    
    public static Hungry getInstance(){
        return h;
    }
}

懒汉式

//懒汉式
//单线程可用，但多线程下会失效；
public class Lazy {
    private Lazy(){}

    private static Lazy lazy;

    public static Lazy getInstance(){
        if(null==lazy) {
            lazy = new Lazy();
        }
        return lazy;
    }
}

懒汉式-多线程版

//懒汉式-多线程
public class Lazy {
    private Lazy(){}
    //防止指令重排导致的线程不安全
    private volatile static Lazy lazy;
    //DCL 双重检测锁
    public static Lazy getInstance(){
        if(null==lazy) {
            synchronized (Lazy.class) {
                if(null==lazy) { //dc
                    //java创建对象分3步
                    //1.分配内存空间
                    //2.执行构造方法，创建对象
                    //3.将对象指向空间
                    //没有volatile ，如果指令重排，先执行1.3， 那么拿到对象后会发现，是一个空对象。
                    lazy = new Lazy();
                }
            }
        }
        return lazy;
    }
    //但是可以通过反射破坏构造器
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);//通过反射破坏私有构造器
        Lazy lazy1 = declaredConstructor.newInstance();//然后就可以新建实例
        Lazy lazy2 = declaredConstructor.newInstance();//然后就可以新建实例
    }
}

懒汉式-终极进阶版（防止反射破坏私有构造器）

上一个版本中，通过反射的方式破坏了私有构造器，从而破解了单例模式，这里可以使用一个不公开的变量来防止破解（只要不被反编译源码）

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

//懒汉式-多线程
public class Lazy {
    //增加一个参数用于控制单例，只要不被反编译代码，就能保证单例安全。
    private static boolean askdmalskndmlkasnd = true;
    private Lazy(){
        synchronized (Lazy.class){
            if(askdmalskndmlkasnd){
                askdmalskndmlkasnd =false;
            }else{
                throw new RuntimeException("不要瞎搞反射，骚年，你破不了的");
            }
        }
    }
    //防止指令重排导致的线程不安全
    private volatile static Lazy lazy;
    //DCL 双重检测锁
    public static Lazy getInstance(){
        if(null==lazy) {
            synchronized (Lazy.class) {
                if(null==lazy) { //dc
                    //java创建对象分3步
                    //1.分配内存空间
                    //2.执行构造方法，创建对象
                    //3.将对象指向空间
                    //没有volatile ，如果指令重排，先执行1.3， 那么拿到对象后会发现，是一个空对象。
                    lazy = new Lazy();
                }
            }
        }
        return lazy;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);//通过反射破坏私有构造器
        Field askdmalskndmlkasnd = Lazy.class.getDeclaredField("askdmalskndmlkasnd");//如果反编译了源码发现了这个参数，那么也能根据反射获取并修改这个参数
        askdmalskndmlkasnd.setAccessible(true);
        Lazy lazy1 = declaredConstructor.newInstance();//然后就可以新建实例
        askdmalskndmlkasnd.set(lazy1,true);//lazy1实例化后，又把这个参数改成true，从而又破坏了单例
        Lazy lazy2 = declaredConstructor.newInstance();//然后就可以新建实例
    }

但是，还是会有破坏！不是绝对安全的

终极版 ENUM枚举类单例模式

public enum EnumTest {
    INSTANCE;

    public EnumTest getInstance(){
        return INSTANCE;
    }
    //破坏不了枚举的单例模式，除非改jdk
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Constructor<Lazy> declaredConstructor = Lazy.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);//通过反射破坏私有构造器
        Lazy lazy1 = declaredConstructor.newInstance();//然后就可以新建实例
        Lazy lazy2 = declaredConstructor.newInstance();//然后就可以新建实例
    }
}

CAS 理念

Compare and Set 比较并交换

比较过当前值与期望值，若一致，才做变更的操作。

以原子类为例：AtomicInteger，

有一个方法getAndIncrement();其底层调用了unsafe类的getAndAddInt（this,valueOffset,1）; 是直接对内存操作的。

将对象的属性的当前值得内存地址拿出来传入方法，在方法中再次根据该内存地址再次获取值，与传进来的值对比。只有当这个值与最新拿出来的值相比，如果相同则＋1，不同则重复上一步查询的操作（自旋锁）。

<将源码截取出来说明>

原子引用：解决ABA问题

ABA问题

A拿到一个值m=5 ，他准备操作的时候，m被B改成了20，然后又把它改成了5，然后A操作的时候，m还是5,但是已经被B改过了。但是A不知道。

原子引用解决ABA问题

总结：加个版本号，每次操作就要给版本号+1；

如何排查死锁

1.获取当前运行的java进程号 jps -l

2.查看信息 jstack 进程号