【锁】ReentrantLock如何实现公平锁/非公平锁

最新推荐文章于 2024-05-11 16:09:01 发布
最新推荐文章于 2024-05-11 16:09:01 发布
阅读量3.7k 收藏 5
点赞数 3
分类专栏： Java基础 文章标签： java 多线程 并发编程 公平锁 ReentrantLock
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/numbbe/article/details/113243325
版权
本文深入解析了Java并发库中的ReentrantLock，对比分析了公平锁与非公平锁的实现原理及执行流程。公平锁在多线程竞争中遵循先来后到的原则，而非公平锁则允许线程抢占，性能更优但可能导致线程饥饿。文章通过源码展示了公平锁与非公平锁的尝试获取锁的策略，揭示了非公平锁性能优于公平锁的原因。
摘要由CSDN通过智能技术生成

目录

同花顺

物竞天择，优胜劣汰。

大自然的生存法则，在Java里也异常适用。

ReentrantLock默认就是采用非公平锁，让线程们自己去竞争。

初中时，学校食堂打饭插队现象，屡禁不止，这就是不公平的。

有些强壮的小伙子，每次都插队，每次都能吃到饭。

可怜的小老犇，老老实实的排队，他们都吃完了，才轮到我，然后正好没饭了，饿肚子吧。

在这里插入图片描述

在这里插入图片描述

源码分析

瞅瞅ReentrantLock的源码，大体上能看懂，就明白公平锁和非公平锁是如何实现的了。

在注释里，我把一些鸟文都去掉了，剩下的都是能看懂的。

ReentrantLock类里一共由三部分组成。

  • ReentrantLock类中有三个内部类。
  • Sync：继承AQS。
  • NonfairSync:继承Sync。
  • FairSync：继承Sync。

package java.util.concurrent.locks;
import java.util.concurrent.TimeUnit;
import java.util.Collection;

public class ReentrantLock implements Lock, java.io.Serializable {


  //首先，就是我们最经常使用的构造方法，默认使用的都是非公平锁。
  //NofairSync，就是不公平锁的意思。
  public ReentrantLock() {
        sync = new NonfairSync();
    }

    //这里,你也可以构造一个公平锁出来,传递true参数即可。
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }


    //下边这么长，是一个内部类Sync。
    //我们的公平锁，非公平锁都是集成Sync，自然里边的方法都可以用。
    //很长，不用看，看下边的公平锁和非公平锁就可以。
    abstract static class Sync extends AbstractQueuedSynchronizer {
    
		//非公平锁就是这个，非公平锁类里判断能不能获取锁就是通过这个方法搞的。
		//将非公平锁的这个方法，与公平锁的这个方法一对比。
		//其意自现。
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }


 	//非公平锁
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
        这里可以看到这个方法compareAndSetState()
        比较并改变状态，简称CAS，这个和CAS思想是一样的。
        看看state是不是0，是0的话就修改状态为1.
        并获取锁，设置锁线程为当前自己线程。**/

		//非公平锁的lock方法
		//如果执行成功，则获取锁，失败，则执行acquire(1)方法。
		//acquire()方法在AbstractQueuedSynchronizer内部。
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
        
		//这里非公平锁调用了父类Sync里的方法，判断是否可以进入获取锁。
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

   //公平锁
    static final class FairSync extends Sync {

		//上锁，修改状态state为1。
        final void lock() {
            acquire(1);
        }
		//在多线程竞争锁的时候，谁能获取小红的欢心，获取锁就是这个方法。
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
            	//非公平锁那里的判断是两个
            	//公平锁这里的判断是三个判断
            	//相比非公平锁，这里多了一个判断，判断一下自己本线程是否在等待队列的首部。
            	//另外两个操作一样，都是CAS操作以及获取锁操作。
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

  
    //这里是ReentrantLock的方法，可以看到它使用的是内部类Sync的方法。
    //所以使用ReentrantLock时，下边很多方法都是Sync的，其实就是使用的Sync。
    //默认使用的都是非公平锁的lock()方法。
    public void lock() {
        sync.lock();
    }

   //统一都是Sync的方法。
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    //统一都是Sync的方法。
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }

    //统一都是Sync的方法。
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    //统一都是Sync的方法。
    public void unlock() {
        sync.release(1);
    }

    //统一都是Sync的方法。
    public Condition newCondition() {
        return sync.newCondition();
    }
    
    //统一都是Sync的方法。
    public boolean isLocked() {
        return sync.isLocked();
    }

  	//统一都是Sync的方法。
    public final boolean isFair() {
        return sync instanceof FairSync;
    }

  	//统一都是Sync的方法。
    protected Thread getOwner() {
        return sync.getOwner();
    }

    //统一都是Sync的方法。
    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    //统一都是Sync的方法。
    public final boolean hasQueuedThread(Thread thread) {
        return sync.isQueued(thread);
    }

    //统一都是Sync的方法。
    public final int getQueueLength() {
        return sync.getQueueLength();
    }

    //统一都是Sync的方法。
    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }

    //统一都是Sync的方法。
    public boolean hasWaiters(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    //统一都是Sync的方法。
    public int getWaitQueueLength(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

    //统一都是Sync的方法，看似你使用的是ReentrantLock但是实际上内部已经被Sync腐蚀了。
    protected Collection<Thread> getWaitingThreads(Condition condition) {
        if (condition == null)
            throw new NullPointerException();
        if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
            throw new IllegalArgumentException("not owner");
        return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
    }

   
    public String toString() {
        Thread o = sync.getOwner();
        return super.toString() + ((o == null) ?
                                   "[Unlocked]" :
                                   "[Locked by thread " + o.getName() + "]");
    }
}

执行流程

非公平锁

1、各个线程争夺CPU的执行权，线程小王争夺到了。

2、观察state为0，执行CAS操作，修改状态，修改持有线程为小王，并获取锁。

3、小王完事了，该小绿上场了，小绿观察state为0，我要进去了。

4、小绿在即将进去的那一刻，老王给他戴了帽子，因为老王也观察到state为0，身为老司机当然要比小绿厉害了。

5、小王获得锁。

公平锁

1、各个线程争夺CPU的执行权，线程小王争夺到了。

2、观察state为0，执行CAS操作，修改状态，修改持有线程为小王，并获取锁。

3、小王完事了，该小绿上场了，小绿观察state为0，我要进去了。

4、小绿在即将进去的那一刻，老王想给他戴帽子，但是老王的距离太短了，他是等待队列中的二号位，只有一号位才能给别人戴帽子。

5、小绿获得锁。

公平锁的实现多了一步，线程判断一下自己在不在队列的首位。

在首位，则获取锁。不在首位，等着吧。

有什么不同

公平锁与非公平锁就是等待队列中的线程排队不排队的问题。

公平锁/非公平锁优劣

公平锁

优点：大锅饭，统一分配资源。

缺点：性能下降很多，第一个线程释放锁后，如果还想再次获取锁，需要进入等待队列尾部，重新排队，进入阻塞状态，等待CPU唤醒。

非公平锁

优点：强者恒强，性能高。

缺点：弱者恒弱，抢不到饭吃。

强大的线程，弱小的线程，弱小的不行啊，一直抢不到。

为什么非公平锁的性能优于公平锁

参考：

这篇文章有详细的代码测试。

https://blog.csdn.net/qq_34436819/article/details/102869353

小老犇
关注
专栏目录
源码解读 | Java中ReentrantLock的实现原理
字节幺零二四的博客
08-02 623
本文将介绍Java中ReentrantLock的实现原理，从源码层面讲解公平锁和非公平锁的加锁、释放锁的流程，以及条件变量的实现。
图解ReentrantLock公平锁和非公平锁实现
m0_73311735的博客
10-13 4045
ReentrantLock是Java并发中十分常用的一个类，具备类似synchronized锁的作用。但是相比synchronized, 它具备更强的能力，同时支持公平锁和非公平锁。指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。多个线程加锁时直接尝试获取锁，能抢到锁到直接占有锁，抢不到才会到等待队列的队尾等待。那ReentrantLock中具体是怎么实现公平和非公锁的呢？它们之间又有什么优缺点呢？本文就带大家一探究竟。
reentrantLock是怎样实现公平锁的
codertcm的博客
04-12 246
在构造ReentrantLock对象时，可以通过参数来指定是公平锁还是非公平锁，默认情况下是非公平锁。当释放锁的线程释放锁时，它会检查等待队列中是否有线程等待获取锁。当ReentrantLock被设置为公平锁时，它会尽量按照等待时间的顺序来获取锁，确保等待时间最长的线程最先获得锁。需要注意的是，公平锁会增加锁的竞争和线程切换的开销，可能会降低整体的性能，尤其在高并发的情况下。入队： 当一个线程尝试获取锁时，如果锁已经被其他线程持有，则该线程会进入等待队列，按照先后顺序排队等待获取锁。
并发操作之——公平锁和非公平锁的区别以及ReenTrantLock源码
weixin_42397937的博客
09-11 3701
并发操作 并发操作之——公平锁和非公平锁的区别 并发操作之——公平锁和非公平锁的区别并发操作一、公平锁和非公平锁的区别二、ReenTrantLock源码总结 一、公平锁和非公平锁的区别 公平锁是先入先出原则，先申请的先加锁，轮流加锁 非公平锁是每个线程都去抢锁，谁抢到锁，谁就加锁。 二、ReenTrantLock源码 非公平锁 static final class NonfairSync extends Sync { private static final long ser
Java高频面试题，ReentrantLock 是如何实现锁公平和非公平性的？
热门推荐
LoveSummer
02-15 5万+
我先解释一下个公平和非公平的概念。公平，指的是竞争锁资源的线程，严格按照请求顺序来分配锁。非公平，表示竞争锁资源的线程，允许插队来抢占锁资源。默认采用了非公平锁的策略来实现锁的竞争逻辑。其次，内部使用了AQS来实现锁资源的竞争，没有竞争到锁资源的线程，会加入到AQS的同步队列里面，这个队列是一个FIFO的双向链表。在这样的一个背景下，公平锁的实现方式就是，线程在竞争锁资源的时候判断AQS同步队列里面有没有等待的线程。如果有，就加入到队列的尾部等待。
源码角度来分析ReentrantLock是怎么利用AQS来实现公平锁，和非公平锁
Perfect is shit
07-27 661
ReentrantLock这篇文章是从JDK8的ReentrantLock源码角度来分析ReentrantLock是怎么利用AQS来实现公平锁，和非公平锁的。所以前提需要理解AQS。 /** * A reentrant mutual exclusion {@link Lock} with the same basic * behavior and semantics as t
ReentrantLock的公平锁机制如何实现的？（源码理解）
adru的博客
02-04 661
接下来，方法获取头节点的下一个节点（s = h.next），并检查该节点是否为null或者该节点的线程不是当前线程（s.thread!是指多个线程按照申请锁的顺序来获取锁，即线程会直接进入队列中排队，队列中的第一个线程才能获得锁。这种机制确保了线程获取锁的公平性，避免了“饥饿”现象，即等待时间过长的线程无法获取到锁的情况。默认情况下，ReentrantLock是非公平的，这是因为非公平锁的效率通常要高于公平锁。在没有特殊需求的情况下，一般推荐使用非公平锁，因为它能提供更高的性能。，则表示成功获取锁。
ReentrantLock源码详解--公平锁、非公平锁
08-25
ReentrantLock的lock()方法是通过调用sync属性的lock()方法实现的，sync是公平锁或非公平锁的实例。如果是公平锁，会调用FairSync的lock()方法，否则调用NonfairSync的lock()方法。lock()方法会调用AQS的acquire()...
图解 ReentrantLock 公平锁和非公平锁实现
Q54665642ljf的博客
10-17 486
ReentrantLock 是 Java 并发中十分常用的一个类，具备类似 synchronized 锁的作用。但是相比 synchronized, 它具备更强的能力，同时支持公平锁和非公平锁。指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。多个线程加锁时直接尝试获取锁，能抢到锁到直接占有锁，抢不到才会到等待队列的队尾等待。那 ReentrantLock 中具体是怎么实现公平和非公锁的呢？它们之间又有什么优缺点呢？本文就带大家一探究竟。
ReentrantLock非公平锁实现原理解读
JMU_software19的博客
12-17 863
概述 ReentrantLock基于AQS，在并发编程中可以实现公平锁和非公平锁来对共享资源进行同步，同时和synchronized一样，支持锁重入，除此之外，RenentrantLock更加灵活，支持实现更多丰富的功能。说到ReentrantLock根据它的中文名，翻译过来叫做，可重入锁。但是仅仅用可重入一个特性来描述ReentrantLock好像有点以偏概全，其公平锁，非公平锁的实现，以及condition的实现似乎都很重要。所以这也是编程人员命名的一个烦恼。 基于上...
java 线程公平锁与非公平锁详解及实例代码
08-31
下面是一个简单的ReentrantLock公平锁与非公平锁的使用示例： ```java import java.util.concurrent.locks.ReentrantLock; public class LockDemo { private ReentrantLock fairLock = new ReentrantLock(true); ...
知识点: Java公平锁与非公平锁 原理讲解ReentrantLock 锁的饥饿效应及解决办法
码农杰森
06-14 2615
公平锁与非公平锁理论前言AQS公平锁非公平锁ReentrantLock 使用ReentrantLock 解决饥饿效应 本文知识： 公平锁与非公平锁理论 AQS的理论与原理讲解 公平锁与非公平锁原理讲解 ReentrantLock的使用 非公平锁饥饿效应解决方法 在上篇中分析了Java并发编程中悲观锁与乐观锁的实现算法，并分析了原子类中使用CAS算法实现乐观锁以及ABA、自旋等问题。 延续上篇继续导论Java ReentrantLock锁，如果实现公平锁与非公平锁。 前言 公平锁：多个线程申请锁时是相对公
ReentrantLock实现公平锁和非公平锁
qq_35270686的博客
02-03 628
ReentrantLock公平锁，非公平锁实现
【Java面试】ReentrantLock 是如何实现锁公平和非公平性的 ？
跟着Mic学架构
06-24 414
好的。我先解释一下个公平和非公平的概念。公平，指的是竞争锁资源的线程，严格按照请求顺序来分配锁。非公平，表示竞争锁资源的线程，允许插队来抢占锁资源。ReentrantLock默认采用了非公平锁的策略来实现锁的竞争逻辑。其次，ReentrantLock内部使用了AQS来实现锁资源的竞争，没有竞争到锁资源的线程，会加入到AQS的同步队列里面，这个队列是一个FIFO的双向链表。在这样的一个背景下，公平锁的实现方式就是，线程在竞争锁资源的时候判断AQS同步队列里面有没有等待的线程。如果有，就加入到队列的尾部等待。而
ReentrantLock分为公平锁和非公平锁，那底层分别是如何实现的
最新发布
wei7a7a7a的博客
05-11 724
无论是公平锁还是非公平锁，它们都使用了AQS的内部FIFO队列来管理等待的线程，以及通过状态位（state）和等待节点（Node）来协调线程的阻塞与唤醒。如果有其他线程已经在等待队列中，那么新来的线程就会加入到队列的末尾排队等待，而不是尝试直接获取锁。非公平锁在尝试获取锁时，不管队列中是否有其他线程在等待，总是会先尝试直接通过CAS操作快速获取锁，这可能导致新来的线程“插队”，获得锁的机会优于已经在队列中等待的线程。2. 如果快速获取失败，非公平锁仍然可能会继续尝试CAS获取锁，即使队列中已有等待线程。
ReentrantLock源码浅析（公平锁，非公平锁如何实现）
qq_32459653的博客
08-03 499
ReentrantLock 有两种实现锁的方式 一种是非公平的，一种是公平的，默认的实现方式是非公平的，但不管哪种实现方式，ReentrantLock都是依靠的它的静态内部了syc来实现，底层的实现机制都是利用volatitle语义 和操作系统提供的CAS原语来实现 所以在看本篇博文时请确保你有以上基础 ，下面上源码 （jdk1.8） public ReentrantLock() { ...
ReentrantLock 源码分析 - 公平锁的 lock() 方法实现
nimo10050的博客
04-28 234
前言 上一篇文章 ReentrantLock 源码分析 - 非公平锁 lock()方法 分析了 非公平锁 的实现方式。 本文接着介绍 公平锁 的具体实现，什么是公平锁和非公平锁请参考 ReentrantLock 源码分析 - 并发编程小知识 正文 AQS 知识回顾 AQS 是一个双向队列，从队列中的第二个节点开始，节点中的线程才可以参与锁竞争，第一个节点被称为“虚节点” 或者 “哨兵节点”。...
「每天一道面试题」ReentrantLock是如何实现公平锁及可重入的？
JavaQ
11-11 1738
A、B两个线程同时执行lock()方法获取锁，假设A先执行获取到锁，此时state值加1，如果线程A在继续执行的过程中又执行了lock()方法(根据持有锁的线程是否是当前线程，判断是否可重入，可重入state值加1)，线程A会直接获取锁，同时state值加1，state的值可以简单理解为线程A执行lock()方法的次数；当线程B执行lock()方法获取锁时，会将线程B封装成Node节点，并将其插入...
reentrantlock的公平锁和非公平锁
07-16
ReentrantLock 提供了两种锁的公平性选择：公平锁（fair lock）和非公平锁（non-fair lock）。 1. 公平锁（fair lock）：公平锁是指多个线程按照请求锁的顺序来获取锁。当一个线程请求锁时，如果锁是可用的，那么它会立即获得锁。如果锁已经被其他线程持有，那么该线程会被放入等待队列中，按照先进先出（FIFO）的顺序等待锁的释放。公平锁保证了所有线程都有公平竞争获取锁的机会，避免了饥饿现象。 要创建一个公平锁，可以在创建 ReentrantLock 对象时传入 true 参数： ```java ReentrantLock lock = new ReentrantLock(true); // 创建一个公平锁 ``` 2. 非公平锁（non-fair lock）：非公平锁是指多个线程获取锁的顺序是不确定的，可能会导致某些线程连续多次获取到锁，而其他线程一直无法获取到锁。非公平锁相比于公平锁具有更高的吞吐量，因为它减少了线程切换的开销。 要创建一个非公平锁，可以在创建 ReentrantLock 对象时不传入任何参数（默认即为非公平锁）： ```java ReentrantLock lock = new ReentrantLock(); // 创建一个非公平锁 ``` 在大多数情况下，默认的非公平锁能够提供较好的性能。如果您希望保证线程获取锁的公平性，可以选择使用公平锁。需要注意的是，公平锁的性能可能会相对较低，因为它需要维护等待队列中线程的顺序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值