【JUC】010-深入单例模式、CAS、ABA问题、可重入锁、自旋锁、死锁排查

最新推荐文章于 2023-07-18 17:38:07 发布
最新推荐文章于 2023-07-18 17:38:07 发布
阅读量518 收藏 2
点赞数
分类专栏： JUC 文章标签： 设计模式 juc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29689343/article/details/110688003
版权

目录

一、深入单例模式

1、之前的笔记

2、双重检测锁的（DCL）懒汉式 + volatile

代码：

3、使用反射破解单例模式

代码：

结果：

4、防止单例模式被反射破解

概述：

代码：

结果：

5、但是

二、CAS

概述：

缺点：

代码：

三、ABA问题

1、问题引出

2、原子引用

代码：

结果：

四、可重入锁

1、代码

2、说明

3、Lock 版

五、自旋锁

1、引出

2、自己写个锁

3、测试

4、测试结果

六、死锁排查

1、图示

2、死锁代码

3、解决方式1：使用 jps -l 定位进程号

4、解决方式2：使用 jstack 进程号 找到死锁问题

5、面试回答

一、深入单例模式

（这里是在之前笔记的基础上进行补充；）

1、之前的笔记

https://blog.csdn.net/qq_29689343/article/details/105046493

2、双重检测锁的（DCL）懒汉式 + volatile

代码：

package com.zibo.singleton;

//懒汉式
public class LazyMan {
    private LazyMan(){

    }
    private volatile static LazyMan lazyMan;

    //双重检测锁的懒汉式 DCL懒汉式 + volatile
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if(lazyMan==null){
                    lazyMan = new LazyMan();//不是原子性操作
                    /*
                     * 底层操作步骤：
                     * 1、分配内存空间；
                     * 2、执行构造方法，初始化对象；
                     * 3、将这个对象指向这个空间；
                     * 指令重排会导致这个顺序混乱，导致lazyMan未真正完成初始化，此时就需要再加上volatile关键字
                     */
                }
            }
        }
        return lazyMan;
    }

}

3、使用反射破解单例模式

代码：

package com.zibo.singleton;

import java.lang.reflect.Constructor;

//懒汉式
public class LazyMan {
    private LazyMan(){

    }
    private volatile static LazyMan lazyMan;

    //双重检测锁的懒汉式 DCL懒汉式 + volatile
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if(lazyMan==null){
                    lazyMan = new LazyMan();//不是原子性操作
                    /*
                     * 底层操作步骤：
                     * 1、分配内存空间；
                     * 2、执行构造方法，初始化对象；
                     * 3、将这个对象指向这个空间；
                     * 指令重排会导致这个顺序混乱，导致lazyMan未真正完成初始化，此时就需要再加上volatile关键字
                     */
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws Exception {
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        LazyMan instance1 = constructor.newInstance();
        System.out.println(instance);
        System.out.println(instance1);
    }
}

结果：

（两个对象）

4、防止单例模式被反射破解

概述：

在构造方法中做判断；

代码：

package com.zibo.singleton;

import java.lang.reflect.Constructor;

//懒汉式
public class LazyMan {
    private volatile static LazyMan lazyMan;
    private static boolean flag = false;
    private LazyMan(){
        synchronized (LazyMan.class){
            if(flag){
                throw new RuntimeException("不要试图使用反射破解单例！");
//                if(lazyMan!=null){
//                    throw new RuntimeException("不要试图使用反射破解单例！");
//                    //这个时候仍然会出现一个问题，就是两个对象都是用反射创建，也会破解单例模式，设置标志位记录之
//                }
            }else {
                flag = true;
            }
        }

    }

    //双重检测锁的懒汉式 DCL懒汉式 + volatile
    public static LazyMan getInstance(){
        if(lazyMan==null){
            synchronized (LazyMan.class){
                if(lazyMan==null){
                    lazyMan = new LazyMan();//不是原子性操作
                    /*
                     * 底层操作步骤：
                     * 1、分配内存空间；
                     * 2、执行构造方法，初始化对象；
                     * 3、将这个对象指向这个空间；
                     * 指令重排会导致这个顺序混乱，导致lazyMan未真正完成初始化，此时就需要再加上volatile关键字
                     */
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws Exception {
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        LazyMan instance1 = constructor.newInstance();
        System.out.println(instance);
        System.out.println(instance1);
    }
}

结果：

5、但是

道高一尺，魔高一丈！

这样并不是最安全的，可以使用反射将flag的值进行修改，在创建一个对象后，将flag修改成false，然后就可以继续创建对象；

二、CAS

概述：

比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作，否是就一直循环判断（自旋锁）；

缺点：

①循环耗时；

②一次只保证一个共享变量的原子性；

③存在ABA问题；

代码：

package com.zibo.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    //CAS compareAndSet：比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        //expect期望；update更新；
        //public final boolean compareAndSet(int expect, int update)
        //如果期望值达到了就更新，否则不更新 CAS是CPU的并发原语
        atomicInteger.compareAndSet(2020,2021);//期望是2020，如果是2020，则更新为2021
        System.out.println(atomicInteger);
    }
}

三、ABA问题

1、问题引出

（有一个线程将1改成3，又改回去了）

2、原子引用

带版本号的原子操作；

代码：

package com.zibo.cas;

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

public class CASDemo {
    //CAS compareAndSet：比较并交换
    public static void main(String[] args) {
        //注意：如果泛型是包装类，注意对象的引用问题
        AtomicStampedReference<Integer> reference = new AtomicStampedReference(1,1);
        new Thread(()->{
            int stamp = reference.getStamp();//获得当前版本号
            System.out.println("a1=>" + stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("a_" + reference.compareAndSet(1, 2, reference.getStamp(), reference.getStamp() + 1));
            System.out.println("a2=>" + reference.getStamp());
            System.out.println("a_" + reference.compareAndSet(2, 1, reference.getStamp(), reference.getStamp() + 1));
            System.out.println("a3=>" + reference.getStamp());
        }).start();
        new Thread(()->{
            int stamp = reference.getStamp();//获得当前版本号
            System.out.println("b1=>" + stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("b_" + reference.compareAndSet(1, 2, reference.getStamp(), reference.getStamp() + 1));
            System.out.println("b2=>" + reference.getStamp());
        }).start();
    }
}

结果：

a1=>1
b1=>1
b_false
a_true
b2=>2
a2=>2
a_true
a3=>3

四、可重入锁

1、代码

package com.zibo.lock01;

// 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");
    }
}

2、说明

3、Lock 版

package com.zibo.lock01;

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();
        }
    }
}

五、自旋锁

1、引出

（自旋锁：不断尝试，直到成功！）

2、自己写个锁

package com.zibo.lock01;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinlockDemo {
    // 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);
    }
}

3、测试

package com.zibo.lock01;

import java.util.concurrent.TimeUnit;

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
// ReentrantLock reentrantLock = new ReentrantLock();
// reentrantLock.lock();
// reentrantLock.unlock();
// 底层使用的自旋锁CAS
        SpinlockDemo lock = new SpinlockDemo();
        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } 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、测试结果

六、死锁排查

1、图示

2、死锁代码

package com.zibo.lock01;

import java.util.concurrent.TimeUnit;

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 final String lockA;
    private final 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);
            }
        }
    }
}

3、解决方式1：使用 jps -l 定位进程号

4、解决方式2：使用 jstack 进程号 找到死锁问题

5、面试回答

看面试和看堆栈信息；

訾博ZiBo
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
多线程常见锁策略—乐观悲观、自旋、读写、ABA问题及解决
ZhangHahaaha的博客
05-28 604
目录常见锁策略乐观锁悲观锁共享锁自旋锁可重入锁公平锁读写锁常见面试题CAS定义原理应用缺点synchronized 背后的原理 常见锁策略 乐观锁 定义 乐观锁认为数据一般情况下不会产生并发冲突，所以在数据进行提交更新的时候，才会正 式对数据是否产生并发冲突进行检测，如果发现并发冲突了，则让返回用户错误的信息，让用户决定如何去做。 实现 Atomic*家族 AtomicInteger count = new AtomicInteger(0);//int count = 0; count.getAndIn
可重入锁，单例模式
u011009575的博客
11-02 154
优点：节省资源 缺点：不同任务无法并行执行，效率低 package Thread2; /** * 可重入锁示例(单例模式) */ public class ReenTranLockDemo2 { private Object currentThread; private int lockTimes = 0; private ReenTranLockDemo2() {} public static ReenTranLockDemo2 getInstance() {
SpinLock 自旋锁, CAS操作（Compare & Set） ABA Problem
weixin_33884611的博客
08-17 116
SpinLock 自旋锁 spinlock 用于CPU同步, 它的实现是基于CPU锁定数据总线的指令.  当某个CPU锁住数据总线后, 它读一个内存单元(spinlock_t)来判断这个spinlock 是否已经被别的CPU锁住. 如果否, 它写进一个特定值, 表示锁定成功, 然后返回. 如果是, 它会重复以上操作直到成功, 或者spin次数超过一个设定值. 锁定数据总线的指令只能保证一...
CAS(自旋锁优化)及ABA问题
User_meng的博客
03-11 751
CAS (自旋锁 优化) CAS的全称是 compare and swap,他是同步类的基础, javade concurrent中的原子性都是通过CAS进行实现的 **jdk8**中底层调用的native方法是Unsafe文件中的 compareAndSwap jdk11中有了升级调用的native方法是 Unsafe文件中 weakCompareAndSet 原理 按照理解，因为是自旋锁优化，实际不是上锁就是在某个线程在改变volatile之前需要验证一下，要改变的值和预期的值是否一致，如果一
读者写者问题，单例模式，自旋锁
weixin_57023347的博客
09-27 339
一.读者写者问题 1.1 概念 读者和写者问题，描述的就是有些公共数据修改的机会比较少，读的机会反而很多。在编写多线程时，这种情况时非常常见的。比如：登录账户，每次登录的时候都在不断的读取后台数据库中保存的账户和密码信息，但是用户很少会修改。再比如：看新闻，一条新闻会有很多用户浏览，但是很少会有人修改。 通常情况下，再读的过程中，往往伴随着查找，中间耗时比较长。如果给这种代码加上互斥锁，会极大的降低我们程序的效率。但是又一种锁可以专门解决读多写少的情况，...
JUC最详细思维导图，一次了解读写锁，可重入锁，Cas原理，volatile 关键字原理
06-27
本文将深入探讨其中的关键概念，包括读写锁、可重入锁、CAS原理以及volatile关键字。 首先，我们来看读写锁。读写锁允许多个线程同时进行读操作，但在写操作时，只有一个线程能够获得锁。这种设计极大地提高了并发...
Java 多线程与并发(12-26)-JUC锁- ReentrantReadWriteLock详解.pdf
07-26
在Java多线程并发编程中，ReentrantReadWriteLock（可重入读写锁）是一个重要的同步工具，它属于Java并发包（java.util.concurrent.locks）中的一个类。这个锁提供了比标准的synchronized关键字更细粒度的控制，允许...
Java 多线程与并发(11-26)-JUC锁- ReentrantLock详解.pdf
07-26
Java中的ReentrantLock是Java并发包（java.util.concurrent.locks）中的一个高级锁，它是可重入的，意味着一个线程可以多次获取同一锁。在深入ReentrantLock之前，我们首先需要了解Java并发编程的基础，特别是Java...
Java 多线程与并发(9-26)-JUC锁- LockSupport详解.pdf
07-23
Java 多线程与并发(9_26)-JUC锁_ LockSupport详解
Java 多线程与并发(10-26)-JUC锁- 锁核心类AQS详解.pdf
07-23
Java 多线程与并发(10_26)-JUC锁_ 锁核心类AQS详解
实现可重入锁
m1615404392的博客
11-17 428
实现可重入锁 今天突然想了解下 可重入锁，所以写一篇博客记录下，那么一个对象拿到锁后进入到方法后，还允许其他线程在进入吗？当不可能！那么我们来看下代码来模拟下可重入锁的场景。 此图可以看到方法enterA和enterB都有加锁的操作 看下此时的main方法调用了enterA和enterB方法 ，enterA方法进入后执行myLock.lock()拿到了锁，因为Lock（锁）对象是静态的所...
DelphiXE10.2.3实现线程安全访问数据和对象（六）——修复原子自旋锁在极端应用场景下的ABA问题
晴空无彩虹的博客
06-13 1045
     前面几篇贴出的基于原子自旋锁的代码中，会存在一种极端应用场景中CAS 的ABA问题：     AB两个线程同时执行到一条CAS（类似CompareExchange函数）前时，B线程将链表头保存本地变量中，而A线程接着取走链表头上的这个数据，然后在B线程执行到CAS时，A线程又将取走的数据返回给链表头，B线程的链表关系被打乱。     这种情况在我的业务应用中不会发生是因为我取走数据后还要...
CAS原理浅析——自旋锁ABA情况的解决
界王拳十倍
09-07 752
马老师的分析： CAS锁 == 自旋锁：一直不断更新，直到没有人进来就更新成功，一直循环，成功为止。 ABA问题：080，看着一样，但是其实不一样了（女朋友例子） 1 ）加版本，versionControl，给别人1回来变成999 2 ）boolean = markable 保障CAS操作原子性问题：（lock指令）， CAS模拟实现：val加到1000模拟操作 提高并发性能：降低锁的粒度，只对val进行加锁 public class ModelTest { volatile private s
高龄白菜JAVA学习第二十天（单例模式|CAS|原子引用|自旋锁）
mangosea的博客
07-19 139
一、单例模式
装逼名词-ABA CAS SpinLock
weixin_33953249的博客
01-05 132
今天看wiki，看到一个提到什么什么会陷入 race condition &amp; ABA problem。丫的我没听过ABA呀，那么我去搜了一下，如下： http://www.bubuko.com/infodetail-317006.html 《SpinLock 自旋锁, CAS操作（Compare &amp; Set） ABA Problem》   ABA解释如下： 所谓ABA（见维基百科的...
【多线程】(5)（常见的锁策略 CAS的应用场景 实现原子类 实现自旋锁 CAS 的 ABA 问题 Synchronized 原理 优化操作 锁升级/锁膨胀 锁消除 锁粗化）
m0_68800221的博客
07-18 159
CAS: 全称Compare and swap，字面意思:”比较并交换“.我们假设内存中的原数据V，旧的预期值A，需要修改的新值B。比较 A 与 V 是否相等。（比较）如果比较相等，将 B 写入 V。（交换）返回操作是否成功。上述CAS的过程,并非是通过一段代码实现的,而是通过一条CPU指令完成的.也就是说CAS操作是原子的,就可以在一定程度上解决线程安全问题.小结:CAS可以理解成CPU给咱提供的一个特殊指令,通过指令就可以一定程度的处理线程安全问题.
知识点: JAVA 悲观锁与乐观锁原理分析 ABA与自旋效率问题分析及解决
码农杰森
06-11 1403
悲观锁与乐观锁前言悲观锁与乐观锁Java原子类 ABA问题Java原子类 自旋效率问题Java原子类 片面性替换方案 本文知识： 悲观锁与乐观锁原理 ABA问题原理与解决方案 自旋锁原理与问题分析 前言 Java中提供了丰富的锁，每种锁因其特性不同，在适当的场景下展现出非常高的效率，本篇文章旨在通过源码分析、使用场景来讲解Java各种锁以及各种锁适用的场景。 通过对锁的不同含义、适用场景做了如下归类： 悲观锁与乐观锁 悲观锁与乐观锁是一种广义上的锁，体现在看待锁的角度不相同。在Java与数据库中都有广
CAS 浅析（原理、实现自旋锁、ABA的产生与解决）
就这样吧
08-16 862
什么是 CAS CAS（compare and swap），比较与交换。 如果普通的比较与交换 public void compareAndSwap(int num1, int num2) { if (num1 == 10) { num2 = 20; } } 这个代码在 被编译成字节码文件等待一些列操作后，将在 CPU 上执行，而代码翻译成的指令不止一条，那就不能保证原子性。 而在 CPU 中，能用一条指令能够成比较与交换。(伪代码） // 如果在这个位置(address) 的值
Java并发编程(七)-各种锁、CAS、ABA、死锁
星光之子的博客
06-21 469
各种锁、CAS、ABA锁的作用锁分类乐观锁CAS（Compare And Swap）CAS的问题ABA自旋时间过长只能保证一个共享变量的原子操作悲观锁自旋锁自旋锁优缺点适应性自旋锁公平锁、非公平锁可重入锁共享锁、独占锁无锁、偏向锁、轻量级锁、重量级锁无锁偏向锁轻量级锁和重量级锁(理解)分段锁读写锁死锁锁优化 锁的作用 Java中的锁 主要用于 保障 多并发线程情况下 数据的一致性。在多线程编程中为了保障数据的一致性，通常需要在使用 对象 或者 方法 之前加锁，这时如果有其他线程也需要使用该对象或者该方法，则
java并发编程-AQS和JUC实战
最新发布
04-29
本篇内容首先介绍了ReentrantLock，一种比synchronized更灵活的重入锁，它支持中断响应、定时尝试获取锁以及公平与非公平的选择。ReentrantLock提供了lock(), lockInterruptibly(), tryLock() 和 tryLock(long time,...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值