如何搞定面试的有关两种锁的热点问题

最新推荐文章于 2023-10-21 16:23:26 发布
最新推荐文章于 2023-10-21 16:23:26 发布
阅读量135 收藏
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37437892/article/details/119494408
版权
本文深入探讨了并发编程中的关键概念，包括无锁CAS（Compare and Swap）机制，其在多线程环境下的应用与ABA问题的解决方案。通过示例展示了乐观锁和悲观锁的区别，并通过AtomicStampedReference解决ABA问题。同时，文章还介绍了自旋锁的概念，以及死锁的产生条件和排查方法。内容涵盖了Java并发编程的基础和进阶知识。
摘要由CSDN通过智能技术生成

CAS 原理

unsafe类

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

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

缺点：

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

如何解决ABA问题

乐观锁：操作数据时非常乐观，认为别人不会同时修改数据，只是在执行更新的时候判断此期间别人是否修改了数据 代表为CAS
悲观锁： 比较悲观，认为别人会修改数据，操作数据时把数据锁住，直到操作完成后才释放锁，操作期间别人不能修改数据 代表为synchronized

加版本号控制，引入原子思想，乐观锁


    @Test
    public void ABA(){

        AtomicStampedReference<Integer> atomicReference = new AtomicStampedReference<Integer>(98,1);
//        值为98 版本号为1

        int version = atomicReference.getStamp();
       new Thread(()->{

           System.out.println(atomicReference.compareAndSet(98, 100, version, version + 1));
           System.out.println("a--->"+atomicReference.getReference()+" 版本"+atomicReference.getStamp());
           System.out.println(atomicReference.compareAndSet(100, 98, atomicReference.getStamp(), atomicReference.getStamp() + 1));
           System.out.println("a--->"+atomicReference.getReference()+" 版本"+atomicReference.getStamp());
       },"线程a").start();
        new Thread(()->{

            System.out.println("正常的线程");
            System.out.println(atomicReference.compareAndSet(98, 9999, version, version + 1));
            System.out.println("b--->"+atomicReference.getReference()+" 版本"+atomicReference.getStamp());

            },"线程b").start();

    
    }

在这里插入图片描述

Integer的自动装箱机制和坑

在这里插入图片描述
在这里插入图片描述

可重入锁

又名递归锁，拿到大门的锁就相当于也拿到了里面小门的锁
在这里插入图片描述

package com.CAS;

import java.util.concurrent.TimeUnit;

public class keChongRu {
    public static void main(String[] args) {

        Phone p = new Phone();
        new Thread(()->{
//            TimeUnit.SECONDS.sleep(2);
            p.sms();
        },"A").start();
        new Thread(()->{
            p.sms();
        },"B").start();
        System.out.println("main");
    }
}

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

    public synchronized void call(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"call");
    }
}

手动Lock版本

package com.CAS;

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

public class keChongRu {
    public static void main(String[] args) {

        PhoneLock p = new PhoneLock();
        new Thread(()->{
//            TimeUnit.SECONDS.sleep(2);
            p.sms();
        },"A").start();
        new Thread(()->{
            p.sms();
        },"B").start();
        System.out.println("main");
    }
}


//手动挡
//锁需要配对，不然会卡住
class PhoneLock{
    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 {
            TimeUnit.SECONDS.sleep(1);

            System.out.println(Thread.currentThread().getName()+"call");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {

            lock.unlock();
        }
    }

}

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

    public synchronized void call(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"call");
    }
}

在这里插入图片描述

自旋锁的实现

一直在那儿死等条件成立

package com.CAS;

import sun.awt.windows.ThemeReader;

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

public class SpinLockPro {
//    引用类型  默认为null
    private AtomicReference<Thread> atomicReference = new AtomicReference<>();

//    自定义加锁
    public void mylock(){
        Thread thread = Thread.currentThread();
        while(!atomicReference.compareAndSet(null,thread)){
//            System.out.println(thread+"等");
        }
        System.out.println(thread+" --->lock");
    }

//    自定义解锁
    public  void myUnLock(){
        Thread thread = Thread.currentThread();
        while (!atomicReference.compareAndSet(thread,null)){

        }
        System.out.println(thread+"=====>解锁了");
    }

    public static void main(String[] args) {
        SpinLockPro spinLockPro = new SpinLockPro();
        new Thread(()->{
            spinLockPro.mylock();
            try {
               TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLockPro.myUnLock();
            }
        },"A").start();

        new Thread(()->{
            spinLockPro.mylock();
            try {
                System.out.println("B");
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                spinLockPro.myUnLock();
            }
        },"B").start();
    }
}

在这里插入图片描述

死锁

产生死锁的条件

  1. 互斥：一个资源每次只能被一个进程使用
  2. 请求与保持：进程因请求资源而阻塞时，对已获得的资源保持不放
  3. 循环等待
  4. 不可剥夺：已获得的资源未使用完之前，不可剥夺
package com.CAS;

import java.util.concurrent.TimeUnit;

public class DeadLock implements Runnable {
    private String l1;
    private String l2;
    public DeadLock(String l1,String l2){
        this.l1= l1;
        this.l2 = l2;
    }
    @Override
    public void run() {
        synchronized (l1){
            System.out.println(Thread.currentThread().getName()+" lock:"+l1+" 想拿"+l2);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (l2){
                System.out.println(Thread.currentThread().getName()+" lock:"+l2+" 想拿"+l1);

            }
        }
    }


    public static void main(String[] args) {
        DeadLock d1 = new DeadLock("A","B");
        DeadLock d2 = new DeadLock("B","A");

        new Thread(d1,"大哥").start();
        new Thread(d2,"王者").start();
    }
}

在这里插入图片描述

死锁的排查

1.日志
2.查看堆栈信息

jps -l 找到运行文件进程号 类似ps -l
jstack 43496 打印堆栈信息
在这里插入图片描述

爱学习的羽
关注
专栏目录
驱动开发面试复习
qq_24093081的博客
03-03 1100
多个程序同时访问一个共享资源产生的问题就叫做竞争。竞争产生的根本原因就是 Linux 系统的并发访问竞争产生的原因如下所示：（1）多线程的并发访问（2）中断程序的并发访问（3）抢占式并发访问所谓并发，就是通过算法将 CPU 资源合理地分配给多个任务，当一个任务执行 I/O 操作时，CPU 可以转而执行其它的任务，等到 I/O 操作完成以后，或者新的任务遇到 I/O 操作时，CPU 再回到原来的任务继续执行。
面试问题总结
小新的博客
09-21 144
1. JAVA基础 2. Spring 3. 数据库和分布式事务 4. 微服务 5. 算法 6. 其他
面试常见问题汇总
qq_42259971的博客
09-16 1055
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。静态编译和动态编译在编译时确定类型，绑定对象运行时确定类型，绑定对象 反射机制优缺点优点： 运行期类型的判断，动态加载类，提高代码灵活度。缺点： 性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多。反射机制的应用场景有哪些？反射是框架设计的灵魂。
JAVA项目面试常谈问题以及个人开场介绍模板
热门推荐
m0_47000756的博客
08-10 1万+
JAVA 人力面试常谈问题 汇总（98个） 1. 请你自我介绍一下 回答提示：一般人回答这个问题过于平常，只说姓名、年龄、爱好、工作经验，这些在简历上都有，其实，企业最希望知道的是求职者能否胜任工作，包括：最强的技能、最深入研究的知识领域、个性中最积极的部分、做过的最成功的事，主要的成就等，这些都可以和学习无关，也可以和学习有关，但要突出积极的个性和做事的能力，说得合情合理企业才会相信。企业很重视一个人的礼貌，求职者要尊重考官，在回答每个问题之后都说一句谢谢.。企业喜欢有礼貌的求职者。 2. 你觉得你个性上
「架构师必备」15个经典面试问题及回答思路
m0_56662340的博客
05-24 3415
前言 人人都想进大厂，当然我也不例外。早在春招的时候我就有向某某某大厂投岗了不少简历，可惜了，疫情期间都是远程面试，加上那时自身也有问题，导致屡投屡败。突然也意识到自己肚子里没啥货，问个啥都是卡卡卡卡，后期下定决心好好弥补我的知识与智商，天天扎在书堆里，再加上实操，自我感觉还是不错的，有进步。 尤其是这我啃了足足58天的[Java进阶架构核心知识集]（文末有介绍，可分享），还是当初朋友面试进大厂后分享给我的。摸熟里边近30个分类的Java知识后，7月下旬鼓足勇气向抖音后端进击，123面（视频面）下来就像开挂
Java常见面试题
西凉的悲伤博客
09-17 754
分布式事务：在分布式系统中一次操作需要由多个服务协同完成，这种由不同的服务之间通过网络协同完成的事务称为分布式事务。例如：小明给张三转账100，A服务器上要先去A数据库扣100，然后B服务器上B数据库加100，两个操作要么都成功，要么都失败。常见的分布式事务解决有：TCC、本地事务表、MQ事务消息等。七种常见分布式事务详解类加载器是实现通过类的权限定名获取该类的二进制字节流的代码块。启动类加载器：负责加载Java核心类库，无法被Java程序直接引用。
一篇文章让你搞定所有redis面试题
05-09 366
Redis是什么 Redis是C语言开发的一个开源的（遵从BSD协议）高性能键值对（key-value）的内存数据库，可以用作数据库、缓存、消息中间件等。它是一种NoSQL（not-only sql，泛指非关系型数据库）的数据库。 redis的优势 性能优秀，数据在内存中，读写速度非常快，支持并发10W QPS 单进程单线程，避免了不必要的上下文切换和竞争条件，不存在多线程导致的CPU切换，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有死锁问题导致的性能消耗。采用IO多路复用机制。虽然没法发挥多
Java开发实战！一篇文章教你搞定计算机网络面试
m0_57064331的博客
07-08 180
第一个 分布式：限流 1.1 ZooKeeper+Nginx面试常备题（附答案） ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括:配置维护、域名服务、分布式同步、组服务等。ZooKeeper的目标就是封装好复杂易出错的关键服务，将简单易用的接口和性能高效、功能稳定的系统提供给用户。 ZooKeeper 是什么？ ZooKeeper 提供了
整理的真实面试被问的面试题（培训机构收集的学生面试过程中被问的问题）
最新发布
weixin_48133130的博客
10-21 299
整理出来的真实面试被问的面试题（培训机构收集的学生面试过程中被问的问题）
淘宝面试常见问题的答案来了，你看了吗？（一面及答案）
mzl_sx的博客
10-15 1390
1、redis sds优缺点、扩容收缩、扩容因子 SDS （简单动态字符串）是什么 其实，SDS 是 Redis 中实现的一种数据结构，主要用来存储字符串。 1、那 SDS 与 C 字符串相比有什么优势呢？ 1.1、常数复杂度获取字符串长度 常规 C 字符串并不记录自身的长度信息，所以为了获取一个 C 字符串的长度，程序必须遍历整个字符串，对遇到的每个字符进行计数，直到遇到代表字符串结尾的空字符为止，这个操作的复杂度为 O(N)。 而 SDS 使用结构体实现，结构体中的 len 属性直接记录
HTTPS面试常问全解析，太厉害了！
m0_56662269的博客
06-10 405
开头 最近一个哥们去面试某当红大厂了，其中几个他印象深刻的面试题你们品品： 1、介绍下如何对MySQL SQL语句进行分析和优化？ 2、Redis 怎样实现的分布式锁？ 3、如何实现本地缓存和分布式缓存？ 4、说一下 JVM 的内存布局和运行原理？ 5、RocketMQ 是怎么存储消息的？源码中有哪些高可用、高性能的设计？ 面试官不愧是大佬，一层接一层的问过来，问完**“Redis 怎样实现的分布式锁”又问“单机锁有哪些？它为什么不能在分布式环境下使用？”** 由于平时只是改改以前的框架代码，哥们当场懵
Java中高级面试必知必会，原理+实战+视频+源码
m0_57066131的博客
07-15 817
结构化数据、非结构化数据与半结构化数据 文章的开始，聊一下结构化数据、非结构化数据与半结构化数据，因为数据特点的不同，将在技术上直接影响存储引擎的选型。 首先是结构化数据，根据定义结构化数据指的是由二维表结构来逻辑表达和实现的数据，严格遵循数据格式与长度规范，也称作为行数据，特点为：数据以行为单位，一行数据表示一个实体的信息，每一行数据的属性是相同的。例如： 因此关系型数据库完美契合结构化数据的特点，关系型数据库也是关系型数据最主要的存储与管理引擎。 非结构化数据，指的是数据结构不规则或不完整，没有任何预
八皇后 java实现
秀
05-20 2519
回朔法： import java.util.Scanner; public class Main{ public static final int N=100; public static int []queen=new int[N]; public static int n; public static int sum=0; public static void main(Stri...
如何4招解决队列中的线程同步、阻塞问题
秀
08-03 1251
读写锁应用背景 package com.unsafe; import java.util.HashMap; import java.util.Map; public class ReadWriteLockPro { public static void main(String[] args) { MyCache myCache = new MyCache(); for (int i = 1; i <= 6; i++) { final
模拟购物车 java程序
秀
04-21 1195
package pra; import java.awt.Choice; import java.awt.Color; import java.awt.Component; import java.awt.Dimension; import java.awt.FlowLayout; import java.awt.Font; import java.awt.Graphics; import ja...
最大子段和 java
秀
05-20 478
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class Main{ public static void main(String args[]) throws NumberFormatException, IOException { ...
springboot扩展功能
秀
08-17 277
异步任务 package com.zhou.springboot09task.service; import org.springframework.stereotype.Service; import java.util.concurrent.TimeUnit; @Service public class AsyncService { public void hello(){ try { TimeUnit.SECONDS.sleep(3);
docker精通之路（上）
秀
08-25 220
run的运行流程图 docker是怎么工作的 Docker是一个client-server结构的系统，Docker的守护进程运行在主机上，通过socket从客户端访问，server收到client的命令就会执行 Docker为什么比虚拟机快 Docker有着比虚拟机更少的抽象层。由于Docker不需要Hypervisor实现硬件资源虚拟化，运行在Docker容器上的程序直接使用的都是实际物理机的硬件资源。 Docker利用的是宿主机的内核，而不需要Guest OS。因此，当新建一个容器时，Docke
面试攻略：解密城市热点面试问题与应对技巧
"城市热点面试问题以及技巧" 面试是求职过程中的关键环节，它不仅是面试官评估应聘者技能和素质的平台，也是应聘者展示自我、争取职位机会的关键时刻。针对城市热点面试问题，以下是一些核心知识点和应对策略： 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值