JUC（个人笔记三）

2、它干嘛的?:官方，其他人的博客，对应的视频
3、它该如何学习？
请你谈谈你对volatile的理解？
Volatile是Java虚拟机提供轻量级的同步机制
1、保证可见性
2、不保证原子性
3、禁止指令重排
Volatile如何保证可见性？

16、JMM

1、什么是JMM？JMM：Java内存模型，不存在的东西，概念约定（为了保证线程的一个安全）
关于JMM的一些同步的约定：
1、线程解锁前，必须把共享变量立刻刷回主存
2、线程加锁前，必须读取主存中的最新值到工作内存中！
3、加锁和解锁必须是同一把锁

线程分为：工作内存和主内存
8种操作：

问题：线程B修改了值Flag=true，A线程还在执行，此时的Flag=false
程序不知道主内存是值已经修改了

17、Volatile

1、保证可见性

package com.itheima.kiki.tvolatile;

import java.util.concurrent.TimeUnit;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/7 9:13
 */
public class VolatileDemo01 {
    //不加volatile，程序就会死循环,加volatile可以保证可见性
    private volatile static int num = 0;
    public static void main(String[] args) throws InterruptedException {//main主线程

        new Thread(()->{//线程1 对主内存的变化是不知道的
            while(num==0){
            }
        }).start();
        TimeUnit.SECONDS.sleep(1);
        num = 1;
        System.out.println(num);
    }

}

2、不保证原子性
原子性：不可分割
线程A在执行任务时，不能被打扰，也不能被分割。要么成功要么失败

package com.itheima.kiki.tvolatile;
/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/7 9:23
 */
/**
 * volatile不保证原子性
 */
public class VolatileDemo02 {
    private volatile static int num = 0;
    public static void add(){
        num++;
    }
    public static void main(String[] args) {
        //理论上num的结果为2万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount()>2){//main gc
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+""+num);
    }

}

如果不加Synchronized或lock，怎样保证原子性?

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

原子类为什么这么高级？（原子类的底层CAS）

package com.itheima.kiki.tvolatile;
/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/7 9:23
 */

import java.util.concurrent.atomic.AtomicInteger;

/**
 * volatile不保证原子性
 */
public class VolatileDemo02 {
    private volatile static AtomicInteger num = new AtomicInteger();
    public static void add(){
        //num++;//不是一个原子性操作
        num.getAndIncrement();//AtomicInteger的加一操作，底层用的CAS（CPU的并发原语，效率极高）
    }
    public static void main(String[] args) {
        //理论上num的结果为2万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount()>2){//main gc
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+""+num);
    }

}

这些类的底层直接和操作系统挂钩！直接在内存中修改值！Unsafe类是一个很特殊的存在
3、禁止指令重排
什么是指令重排？你写的程序，计算机并不是按照你写的那样执行的
源代码–>编译器优化的重排–>指令并行也可能重排–>内存系统也会重排–>执行
处理器在进行指令重排的时候，考虑：数据之间的依赖性！

int x = 1;		//语句1
int y = 2;		//语句2
x = x + 5;		//语句3
y = x * x;		//语句4

我们期望1234，但是也可能变成2134

volatile可以避免指令重排
内存屏障，CPU指令，作用：
1、保证特定的操作的执行顺序
2、可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）

Volatile可以保证可见性，不能保证原子性。由于内存屏障，可以保证避免指令重排的现象产生（内存屏障在单例模式中使用的最多）

18、彻底玩转单例模式(搞懂枚举)

饿汉式：

package com.itheima.kiki.single;
/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/7 9:58
 */
/**
 * 饿汉式单例
 * 构造器私有，一旦私有构造器，别人就无法new对象了，保证内存中只有一个对象
 *
 */
public class HungaryDemo {
    //构造器私有
    private HungaryDemo(){

    }
    //创建对象
    private final static HungaryDemo HUNGARY_DEMO = new HungaryDemo();

    //返回对象实例
    public static HungaryDemo getInstance(){
        return HUNGARY_DEMO;
    }

}

懒汉式（DCL）:

package com.itheima.kiki.single;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/7 10:05
 */

/**
 * 懒汉式单例
 */
public class LazyDemo {
    private LazyDemo(){
        System.out.println(Thread.currentThread().getName()+ "ok");
    }

    private volatile static LazyDemo lazyDemo;

    public static LazyDemo getInstance(){
        //双重检测锁模式的懒汉式单例（DCL懒汉式）
        if(lazyDemo == null){
            synchronized (LazyDemo.class){
                if (lazyDemo == null){
                    lazyDemo = new LazyDemo();//不是原子性操作
                    /**
                     * 1、分配内存空间
                     * 2、执行构造方法，初始化对象
                     * 3、把这个对象指向这个空间
                     *  123
                     *  132 A线程
                     *      B线程 此时lazyDemo还没有完成构造
                     *
                     */
                }
            }
        }
        return lazyDemo;
    }

    //多线程并发
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                lazyDemo.getInstance();
            }).start();
        }
    }

}

静态内部类

package com.itheima.kiki.single;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/7 10:16
 */

/**
 * 静态内部类
 */
public class Holder {
    private Holder(){

    }

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

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

单例不安全，反射可以破坏
枚举类（自带单例模式）
没有无参构造，只有一个两个参数的有参构造
进行反编译

package com.itheima.kiki.single;

import java.lang.reflect.Constructor;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/7 10:34
 */
//enum枚举是什么？本身也是一个Class类
public enum  EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

class Test{
    public static void main (String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        //EnumSingle instance2 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        //Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
        //	at java.lang.reflect.Constructor.newInstance(Constructor.java:416)
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        //Exception in thread "main" java.lang.NoSuchMethodException
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

19、深入理解CAS
什么是CAS？
大厂你必须要深入研究底层！有所突破！（修内功，操作系统，计算机网络原理）

Unsafe类



CAS：比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环。
缺点：
1、循环会耗时
2、一次性只能保证一个共享变量的原子性
3、会存在ABA问题
CAS：ABA问题（狸猫换太子）

package com.itheima.kiki.cas;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/7 13:51
 */
public class CASDemo {


    /**
     *  CAS compareAndSet :比较并交换
     */
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        /**
         * public final boolean compareAndSet(int expect, int update)
         * 期望  更新
         * compareAndSet 如果期望的值达到了，就更新，否则就不更新.CAS是CPU的并发原语
         */
        atomicInteger.compareAndSet(2020,2021);
        System.out.println(atomicInteger.get());//2021
        //atomicInteger.getAndIncrement(); //++
    }
}

20、原子引用

带版本号的原子操作（乐观锁）
解决ABA问题，引入原子引用，对应的思想：乐观锁

package com.itheima.kiki.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/7 13:51
 */
public class CASDemo {
    /**
     *  CAS compareAndSet :比较并交换
     */
    public static void main(String[] args) {
        //AtomicInteger atomicInteger = new AtomicInteger(2020);
        //AtomicStampedReference注意，如果泛型是一个包装类，注意对象的引用问题
        //正常业务操作中，这里比较的是一个对象
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);
        /**
         * 模拟两个线程
         */
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();//获取版本号
            System.out.println("a1=>"+stamp);

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

            System.out.println(atomicStampedReference.compareAndSet(1, 2,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));

            System.out.println("a2=>"+atomicStampedReference.getStamp());

            atomicStampedReference.compareAndSet(2,1,
                    atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);

            System.out.println("a3=>"+atomicStampedReference.getStamp());
        },"a").start();

        new Thread(()->{
            int stamp = atomicInteger.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));
        },"b").start();
    }
}

Integer使用对象缓存机制，默认范围-128到127，推荐使用静态工厂方法valurOf()获取对象实例，而不是new，因为valueOf使用缓存，而new一定会创建新的对象分配新的内存空间；

21、各种锁的理解

1、公平锁、非公平锁
公平锁：非常公平，不能插队，必须先来后到！
非公平锁：非常不公平，可以插队（默认都是非公平锁）
2、可重入锁
可重入锁（递归锁）
Synchronized

package com.itheima.kiki.lock;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/8 8:18
 */
//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");
    }
}

Lock版

package com.itheima.kiki.lock;

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

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/8 8:18
 */
//Lock
public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone2 = new Phone2();

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


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

class Phone2{
    Lock lock = new ReentrantLock();
    public  void sms(){
        lock.lock();//细节问题：lock锁，锁必须配对，否则就会产生死锁
        try {
            System.out.println(Thread.currentThread().getName()+"sms");
            call();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }

    public  void call(){
        //System.out.println(Thread.currentThread().getName()+"call");
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"call");

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

3、自旋锁
spinlock

自定义锁测试

package com.itheima.kiki.lock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/8 8:31
 */
//自旋锁
public class SpinLockDemo {
    //int   0
    //Thread   null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    //加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"====>mylock");
        while (atomicReference.compareAndSet(null,thread)){

        }
    }

    //解锁
    public void myUnlock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"====>myunlock");
        atomicReference.compareAndSet(thread,null);
    }
}

package com.itheima.kiki.lock;

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

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/8 8:36
 */
public class TestSpinLock {
    public static void main(String[] args) throws Exception {
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();

        //底层使用的自旋锁
        SpinLockDemo lock = new SpinLockDemo();
        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                lock.myUnlock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                lock.myUnlock();
            }
        },"T2").start();


    }
}

4、死锁
死锁是什么？
两个人互相争夺资源

package com.itheima.kiki.lock;

import java.util.concurrent.TimeUnit;

/**
 * @author kiki
 * @version 1.0
 * @create 2020/6/8 8:47
 */
public class DeadLockDemo {
    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);
            }
        }
    }
}

解决问题
1、使用jps -l定位进程号

2、使用**‘jstack’ 进程号** 查看进程信息

面试，工作中！排查问题
1、查看日志
2、堆栈信息