大厂面试--公平锁、非公平锁、可重入锁、自旋锁、独占锁和共享锁（即读写锁）

最新推荐文章于 2023-03-04 23:45:00 发布
最新推荐文章于 2023-03-04 23:45:00 发布
阅读量108 收藏
点赞数
分类专栏： 大厂面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45896732/article/details/115932175
版权

公平锁：是指多个线程按照申请锁的顺序来获取锁，类似排队打饭，先来后到。

非公平锁：是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发的情况下，有可能会造成优先级后转或者饥饿现象

两者区别

公平锁/非公平锁

并发包中ReentrantL ock的创建可以指定构造函数的boolean类型来得到公平锁或非公平锁，默认是非公平锁

关于两者区别:

公平锁:

Threads acquire a fair lock in the order in which they requested it

公平锁，就是很公平，在并发环境中，每个线程在获取锁时会先查看此锁维护的等待队列，如果为空，或者当前线程是等待队列的第一个，就占有锁，否则就会加入到等待队列中，以后会按照FIFO的规则从队列中取到自己

非公平锁:

a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lock happens to be available when it is requested.

非公平锁比较粗鲁，上来就直接尝试占有锁，如果尝试失败，就再采用类似公平锁那种式。

Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。

对于Synchronized而言， 也是一 种非公平锁。

可重入锁(也叫做递归锁)

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。

ReentrantLock/Synchronized就是一个典型的可重入锁。

可重入锁最大的作用是避免死锁。

举个栗子：家里最外面的防盗门有一把锁，进去里面后有一个卫生间、卧室、厨房，正常情况下，你厨房和卫生间应该不会上锁吧，即使你卫生间和厨房有门，你一般也不会上锁。所以只要突破防盗门后，进去应该是一马平川,如履平地。

可重入锁代码演示：

package com.company;

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

/*
可重入锁(也叫做递归锁)

指的是同一线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。

也即是说，线程可以进入任何一个它已经拥有的锁所同步着的代码块。
case one Synchronized就是一个典型的可重入锁
t1invoked sendMES t1线程在外层方法获取锁的时候
t1%%%%%%%%%invoked sendEmail  t1在进入内层方法会自动获取锁
t2invoked sendMES
t2%%%%%%%%%invoked sendEmail

case two
ReentrantLock就是一个典型的可重入锁
 */
public class ReenterLockDemo {

    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendMES();
        },"lmx1").start();
        new Thread(()->{
            phone.sendMES();
        },"lmx2").start();
        new Thread(()->{
            phone.run();
        },"lmx3").start();
        new Thread(()->{
            phone.run();
        },"lmx4").start();
    }
}

class Phone implements Runnable{
    Lock lock = new ReentrantLock();
    public synchronized void sendMES(){
        System.out.println(Thread.currentThread().getName()+"invoked sendMES");
        sendEmail();
    }

    public synchronized void sendEmail(){
        System.out.println(Thread.currentThread().getName()+"%%%%%%%%%invoked sendEmail");
    }

    //=================================================================================

    @Override
    public void run() {
        get();
    }

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

    }

    public void set(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"%%%%%%%%%invoked sendEmail");
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
          lock.unlock();
        }
    }
}
/*
运行结果：
lmx1invoked sendMES
lmx1%%%%%%%%%invoked sendEmail
lmx2invoked sendMES
lmx2%%%%%%%%%invoked sendEmail
lmx3invoked sendMES
lmx3%%%%%%%%%invoked sendEmail
lmx4invoked sendMES
lmx4%%%%%%%%%invoked sendEmail
*/

自旋锁（spinlock）

是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文的消耗，缺点是循环会消耗CPU

代码演示：

package com.company;

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

public class SpinLockDemo {

    //原子引用线程

    AtomicReference<Thread> atomicReference = new AtomicReference<>();
    //2.执行该方法，输出t1 come in,thread为null，atomicReference.compareAndSet(null,thread)执行为true，
    // 期望值被换为thread，所以while()判断为false 执行完成
    //5.执行该方法，输出t2 come in，thread为null，atomicReference.compareAndSet(null,thread)执行为false，
    // 因为atomicReference中的期望值已被t1线程置换，所以while判断为true，一直循环
    //8.atomicReference中的期望值被t1置换回null，t2线程atomicReference.compareAndSet(null,thread)执行为true，
    // 期望值被换为thread，所以while()判断为false 执行完成
    public void myLock(){
        Thread thread = Thread.currentThread();//默认为null
        System.out.println(Thread.currentThread().getName()+"\t come in ");

        while (!atomicReference.compareAndSet(null,thread)){//false

        }

    }
    //7.t1执行该方法，比对成功，atomicReference中的期望值置换回null，输出t1	 invoked myUnLock()
    //10.t2执行该方法，比对成功，atomicReference中的期望值置换回null，输出t2	 invoked myUnLock()
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"\t invoked myUnLock()");
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(()->{
            //1.调用上面的myLock()方法
            spinLockDemo.myLock();
            //3.睡眠5秒
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //6.五秒后继续执行，调用myUnLock()方法
            spinLockDemo.myUnLock();
        },"t1").start();
        //main线程睡眠1秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            //4.调用上面的myLock()方法
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //9.调用myUnLock()方法
            spinLockDemo.myUnLock();
        },"t2").start();
    }
}

独占锁:指该锁一次只能被一个线程所持有。对ReentrantLock和Synchronized而言都是独占锁

共享锁:指该锁可被多个线程所持有。

对ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁。

读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥的。

思想：

多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行，但是，如果有一个线程想去写共享资源类，就不应该再有其它线程可以对该资源进行读或写。

总结：

读-读能共存 读-写不能共存 写-写不能共存

代码演示：

无读写锁的：

写操作有加塞，不连续，被打断

package com.company;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/*运行结果
3	 正在写入3
2	 正在写入2
1	 正在写入1
5	 正在写入5
4	 正在写入4
2	 正在读取
3	 正在读取
1	 正在读取
4	 正在读取
5	 正在读取
4	 读取完成4
5	 读取完成5
3	 读取完成3
5	 写入完成
3	 写入完成
2	 读取完成2
4	 写入完成
2	 写入完成
1	 写入完成
1	 读取完成1
*/
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for(int i = 1; i <=5; i++){
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        for(int i = 1; i <=5; i++){
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }
    }
}

class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();

    public void put(String key,Object value){

        System.out.println(Thread.currentThread().getName()+"\t 正在写入"+key);

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

        map.put(key,value);

        System.out.println(Thread.currentThread().getName()+"\t 写入完成");

    }

    public void get(String key){
        System.out.println(Thread.currentThread().getName()+ "\t 正在读取");

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

        map.get(key);

        System.out.println(Thread.currentThread().getName()+ "\t 读取完成" + key);
    }
}

有读写锁的：

严格控制写操作，读写分离，保证数据一致性，也保证了并发性

package com.company;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/*运行结果：
2	 正在写入2
2	 写入完成
1	 正在写入1
1	 写入完成
4	 正在写入4
4	 写入完成
3	 正在写入3
3	 写入完成
5	 正在写入5
5	 写入完成
1	 正在读取
1	 读取完成1
2	 正在读取
2	 读取完成2
3	 正在读取
3	 读取完成3
4	 正在读取
4	 读取完成4
5	 正在读取
5	 读取完成5
*/
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();
        for(int i = 1; i <=5; i++){
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        for(int i = 1; i <=5; i++){
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }
    }
}

class MyCache{

    private volatile Map<String,Object> map = new HashMap<>();

    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public void put(String key,Object value){

        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"\t 正在写入"+key);

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

            map.put(key,value);

            System.out.println(Thread.currentThread().getName()+"\t 写入完成");
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    public void get(String key){

        readWriteLock.writeLock().lock();

        try {

            System.out.println(Thread.currentThread().getName()+ "\t 正在读取");

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

            map.get(key);

            System.out.println(Thread.currentThread().getName()+ "\t 读取完成" + key);
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }
}
学不明白后端的小菜鸡~
关注
专栏目录
聊聊redis分布式锁的8大坑
lisu061714112的专栏
09-24 3804
前言 在分布式系统中，由于redis分布式锁相对于更简单和高效，成为了分布式锁的首先，被用到了很多业务场景当中。 尤其是分布式配置中心：apollo、nocos等的出现，让zookeeper的地位越来越低了。zookeeper分布式锁复杂度更高，想把它使用好并不容易。 所以我们还是好好使用redis分布式锁吧。 不是说用了redis分布式锁，就可以高枕无忧了，如果没有用好，也会引来一些意想不到的麻烦。 今天我们重点聊聊redis分布式锁的一些坑，给有需要的朋友一个参考。 最近无意间获得一份BAT大厂大佬写
java aqs面试题_死磕 java同步系列之AQS终篇（面试）
weixin_35241774的博客
02-13 718
问题(1)AQS的定位？(2)AQS的重要组成部分？(3)AQS运用的设计模式？(4)AQS的总体流程？简介AQS的全称是AbstractQueuedSynchronizer，它的定位是为Java中几乎所有的锁和同步器提供一个基础框架。在之前的章节中，我们一起学习了ReentrantLock、ReentrantReadWriteLock、Semaphore、CountDownLatch的源码，今天...
java.util.concurrent 包中的三把锁(ReentrantLock、ReentrantReadWriteLock、StampedLock)
yuiezt的专栏
03-04 562
如果某个线程已经获得了锁资源，该线程后续再去抢占相同的锁时，不需要再加锁，只需要记录重入次数。上述代码中，ReentrantLockDemo 有一个add()方法，对 非原子性的 num++ 操作加了锁，能够保证 num++ 的线程安全。其实我们想做的是：允许多个线程同时调用查询方法，但是如果有一个线程在调用写入方法，那么这时其他线程不论是调用查询还是写入方法，都要阻塞。为了解决这个问题，引入来StampedLock，它优化了读锁，写锁的访问，其实它是提供了一种乐观锁策略。
可重入锁+自旋锁+读写锁
zyk1.的博客
04-04 195
可重入锁 我们来看什么是可重入锁 可重入锁的核心意思 是同一个线程在外层方法获取锁的时候 在进入内层方法会自动获取锁 这里我们分别举synchronized 和 ReentrantLock的例子 synchronized是可重入锁 package com.robot; class Phone{ //外层方法 public synchronized void sendMes() { ...
JAVA锁机制-可重入锁,可中断锁，公平锁，读写锁，自旋锁
newbei5862的博客
11-15 635
如果需要查看具体的synchronized和lock的实现原理，请参考：解决多线程安全问题-无非两个方法synchronized和lock 具体原理 在并发编程中，经常遇到多个线程访问同一个 共享资源 ，这时候作为开发者必须考虑如何维护数据一致性，在java中synchronized关键字被常用于维护数据一致性。synchronized机制是给共享资源上锁，只有拿到锁的线程才可以访问共享资源，这样就可以强制使得对共享资源的访问都是顺序的，因为对于共享资源属性访问是必要也是必须的，下文会有具体示例演示。 一
【面试专栏】公平锁和非公平锁&可重入锁&自旋锁&独占锁/共享锁
梓莘
12-30 141
文章同步更新在个人公众号“梓莘”，欢迎大家关注，相互交流。 公平锁和非公平锁 公平锁：是指多个线程按照申请锁的顺序来获取锁，也就是遵循先来后到 非公平锁：是指多个线程获取锁的顺序并不是安装申请锁的顺序，有可能后申请锁的线程优先获得锁，在高并发环境下，有可能造成优先级反转或者饥饿现象。非公平就是允许加塞 在并发包ReentrantLock的创建可以执行构造函数的boolean类型来得到公平锁和非...
阿里面试失败后，一气之下我图解了Java中18把锁
热门推荐
华科硕士，大厂打工中。编程问题咨询，请私我
06-17 41万+
目录 乐观锁和悲观锁 独占锁和共享锁 互斥锁和读写锁 公平锁和非公平锁 可重入锁 自旋锁 分段锁 锁升级（无锁|偏向锁|轻量级锁|重量级锁） 锁优化技术（锁粗化、锁消除） 乐观锁和悲观锁 悲观锁 悲观锁对应于生活中悲观的人，悲观的人总是想着事情往坏的方向发展。 举个生活中的例子，假设厕所只有一个坑位了，悲观锁上厕所会第一时间把门反锁上，这样其他人上厕所只能在门外等候，这种状态就是「阻塞」了。 回到代码世界中，一个共享数据加了悲观锁，那线程每次想操作这个数据前都会假设其他线程.
java 共享锁和独占锁_java 中锁（公平锁、非公平锁、可重入锁、自旋锁、独占锁、共享锁）学习篇...
weixin_42393315的博客
02-28 144
大厂常见面试题：java 中锁你知道哪些？java请手写一个自旋锁？面试首先，回答第一个问题：java 中锁你知道哪些？java中有公平锁、非公平锁、可重入锁(递归锁)、自旋锁、独占锁(写锁)、共享锁(读锁)……编程公平锁 和 非公平锁并发是什么：公平锁：是指多个线程按照申请的顺序来获取值函数非公平锁：是值多个线程获取值的顺序并非按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并...
2020金三银四冲击BAT必备面试题（上篇）：集合类+阻塞队列+锁
Java____superman的博客
12-19 3015
本文转载自：2020金三银四冲击BAT必备面试题（上篇）：集合类+阻塞队列+锁 一、集合类 1. ArrayList的扩容机制 每次扩容是原来容量的1.5倍，通过移位的方法实现。 使用copyOf的方式进行扩容。 扩容算法是首先获取到扩容前容器的大小。然后通过oldCapacity + (oldCapacity >> 1) 来计算扩容后的容器大小newCapacity。这里用到了...
redis---分布式锁存在的问题及解决方案（Redisson）
m0_61083409的博客
08-02 2904
初识分布式锁大多数人都是从setNx命令开始的，我们很轻易的就可以借助setNx命令及redis的特性创建一个简陋的分布式锁。释放锁时只需要直接删除即可。存在问题：上述只是列出的一小部分问题，实际还存在很多漏洞没有展示出来。我们循序渐进一点一点啃先解决以上几个问题。对于出现异常锁无法释放问题，我们很容易可以想到能够通过设置一个过期时间来进行处理。比如像订单30分钟未支付默认放弃此订单这样。这里采用常规的SETNX + EXPIRE 为两个单独的命令会缺乏原子性，想象一下如果加锁成功但是客户端节点在执行EXP
悲观锁与乐观锁的实现(详情图解)含面试专题及答案
m0_67322837的博客
04-08 964
一、前言 在了解悲观锁和乐观锁之前，我们先了解一下什么是锁，为什么要用到锁？ 技术来源于生活，锁不仅在程序中存在，在现实中我们也随处可见，例如我们上下班打卡的指纹锁，保险柜上的密码锁，以及我们我们登录的用户名和密码也是一种锁，生活中用到锁可以保护我们人身安全（指纹锁）、财产安全（保险柜密码锁）、信息安全（用户名密码锁），让我们更放心的去使用和生活，因为有锁，我们不用去担心个人的财产和信息泄露。 而程序中的锁，则是用来保证我们数据安全的机制和手段，例如当我们有多个线程去访问修改共享变量的时候，我们可以给
ReentrantLock简介和使用
weixin_43939924的博客
05-12 298
ReentrantLock简介和使用 相对于 synchronized 它具备如下特点 可中断 可以设置超时时间 可以设置为公平锁 支持多个条件变量 与 synchronized 一样，都支持可重入 基本语法: // 获取锁 reentrantLock.lock(); try { // 临界区 } finally { // 释放锁 reentrantLock.unlock(); } 可重入 可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁如果是不可重
公平锁和非公平锁-ReentrantLock是如何实现公平、非公平的
Curry4ever
11-08 1098
目录）1、什么是公平锁与非公平锁2、ReentrantLock如何实现公平与非公平3、公平锁与非公平锁性能对比 1、什么是公平锁与非公平锁 公平锁：公平锁就是保障了多线程下各线程获取锁的顺序，先到的线程优先获取锁。 非公平锁：非公平锁则无法提供这个保障（先到的线程优先获取锁）。 2、ReentrantLock如何实现公平与非公平 Java并发包下面的ReentrantLock、ReadWriteLock默认都是非公平模式。 下面我们就来一起看看ReentrantLock是如何实现公平与非公平的。 Reen
基于ssm的二手车交易网站设计与实现.docx
09-17
基于ssm的二手车交易网站设计与实现.docx
zotero 6 插件,包含茉莉花、DOI、绿青蛙、sci-hub等11个常用插件
09-17
zotero 6 插件，茉莉花、DOI、绿青蛙、sci-hub、Better notes、GPT、IF、PDF翻译、Style、TAG、影响因子
linux_命令_tail_的升级版，可使用_tails_同时跟踪多个文件并格式化输出成更方便查看的_tails.zip
最新发布
09-17
linux_命令_tail_的升级版，可使用_tails_同时跟踪多个文件并格式化输出成更方便查看的_tails
基于ssm的房屋出租出售系统设计与实现.docx
09-17
基于ssm的房屋出租出售系统设计与实现.docx
jdk9 免安装包，配置环境变量即可
09-17
jdk9 免安装包，配置环境变量即可
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值