JUC——Day04

JUC Day04

视频总结自B站狂神说JAVA

1.单例模式

只要是单例模式一定是构造器私有。

1.1 饿汉式

饿汉式单例模式最大的特点就是在程序运行时，会立即将所需要的全部对象创建完毕，会影响加载速度浪费资源。

/**
 * @date 2020/7/29 7:37
 * hungry
 * 饿汉式单例模式
 */
public class Demo01 {

//    在程序执行时都会创建完毕，消耗资源过多。
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];
    private byte[] data5 = new byte[1024*1024];

    private Demo01(){
    }
    private final static Demo01 HUNGRY = new Demo01();

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

1.2 懒汉式

在使用到时在进行加载。

/**
 * @date 2020/7/29 7:43
 * lazy
 * 懒汉式单例模式
 *
 */
public class Demo02 {

    private Demo02(){

    }

    private static Demo02 demo02;

    private static Demo02 getInstance(){
        if (demo02 == null){
            demo02 = new Demo02();
        }
        return demo02;
    }

}

后面没听懂。。。

2.CAS

CAS = compareAndSet ：比较并交换。
比较当前工作内存中的值，与主内存中的值进行交换，如果是期望的值则执行更新操作，如果不是就一直循环。

/**
 * @date 2020/7/29 8:16
 * cas
 */
public class CasDemo01 {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

//        CAS 是CPU的并发原语。
//        JAVA无法自己操作内存，可以调用C++来操做内存。
//        如果期望的值达到了第一个参数，那么就会变成第二个参数。
        atomicInteger.compareAndSet(2020,2021);
        System.out.println(atomicInteger.get());
    }
}

缺点：

1. 循环会耗时；
2. 一次性只能保证一个共享变量的原子性；
3. ABA问题：

2.1 ABA 问题

/**
 * @date 2020/7/29 9:25
 * cas
 * ABA 问题
 */
public class CasDemo02 {
    public static void main(String[] args) {
//        默认范围是 -128~127 之间
        AtomicStampedReference<Integer> atomic = new AtomicStampedReference<>(1,1);


//        A线程
        new Thread(()->{
//            获得版本号
            int stamp = atomic.getStamp();
            System.out.println("A1-->"+stamp);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

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

            System.out.println("A2-->"+atomic.getStamp());


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

            System.out.println("A3-->"+atomic.getStamp());


        },"A").start();


//        B线程
        new Thread(()->{
            int stamp = atomic.getStamp();
            System.out.println("B1-->"+stamp);

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

            atomic.compareAndSet(1,3,stamp,stamp+1);

            System.out.println("B2-->"+atomic.getStamp());


        },"B").start();


    }
}

引入原子引用，可以解决ABA问题。

3. 锁

3.1 公平锁和非公平锁

公平锁：安装线程的先来后到运行，不可以插队。
非公平锁：可以插队，默认。

**/**
 * @date 2020/7/29 9:54
 * 公平锁与非公平锁
 */
public class FairLock {
    public static void main(String[] args) {
//        在创建锁的时候传入参数执行公平与非公平锁，true为公平锁，默认不填为false非公平锁。
        Lock lock = new ReentrantLock(true);
    }
}
**

3.2 可重入锁

也称为递归锁。
拿到了外面的锁，也相当于拿到了里面的锁。

synchornized版：
B线程必须等待A线程执行完毕再次执行。

/**
 * @date 2020/7/29 9:59
 * 可重入锁
 */
public class AgainLock {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sms();
        },"A").start();

        new Thread(()->{
            phone.sms();
        },"A").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版：
lock锁与synchornized不同的是，lock每把锁都必须进行解锁。

/**
 * @date 2020/7/29 10:03
 * lock版 可重入锁
 */
public class AgainLock02 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sms();
        },"A").start();

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

    }
}
class Phone2{
    Lock lock = new  ReentrantLock();

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

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

3.3 自旋锁

不断的去循环，遍历，迭代，直到成功为止。
自定义锁：

/**
 * @date 2020/7/29 10:09
 * 自旋锁
 */
public class SpinlockDemo01 {
    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);
    }

}

测试自定义自旋锁：

/**
 * @date 2020/7/29 10:12
 * 自旋锁测试
 */
public class SpinLockDemo02 {
    public static void main(String[] args) throws InterruptedException {
        SpinlockDemo01 spinlockDemo01 = new SpinlockDemo01();


        new Thread(()->{
            spinlockDemo01.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                spinlockDemo01.myUnLock();
            }
        },"A").start();

//                等待1s让A线程先拿到锁
        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            spinlockDemo01.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                spinlockDemo01.myUnLock();
            }
        },"B").start();
    }
}

3.4 死锁

两个锁互相等待对方释放锁。
排查方案：

1. 使用jsp - l定位进程号；
2. 使用jstack进程号找到死锁；