带你快速了解Java锁中的公平锁与非公平锁

前言

Java语言中有许多原生线程安全的数据结构,比如ArrayBlockingQueue、CopyOnWriteArrayList、LinkedBlockingQueue,它们线程安全的实现方式并非通过synchronized关键字,而是通过java.util.concurrent.locks.ReentrantLock来实现。

锁的底层实现

无论什么语言在操作系统层面锁的操作都会变成系统调用(System Call),以 Linux 为例,就是 futex 函数,可以把它理解为两个函数:futex_wait(s),对变量 s 加锁;futex_wake(s)释放 s 上的锁,唤醒其他线程。

在ReentrantLock中很明显可以看到其中同步包括两种,分别是公平的FairSync和非公平的NonfairSync。

公平锁的作用就是严格按照线程启动的顺序来执行的,不允许其他线程插队执行的;而非公平锁是允许插队的。

默认情况下ReentrantLock是通过非公平锁来进行同步的,包括synchronized关键字都是如此,因为这样性能会更好。

因为从线程进入了RUNNABLE状态,可以执行开始,到实际线程执行是要比较久的时间的。

而且,在一个锁释放之后,其他的线程会需要重新来获取锁。其中经历了持有锁的线程释放锁,其他线程从挂起恢复到RUNNABLE状态,其他线程请求锁,获得锁,线程执行,这一系列步骤。如果这个时候,存在一个线程直接请求锁,可能就避开挂起到恢复RUNNABLE状态的这段消耗,所以性能更优化。

    /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

默认状态,使用的ReentrantLock()就是非公平锁。再参考如下代码,我们知道ReentrantLock的获取锁的操作是通过装饰模式代理给sync的。

    /**
     * Acquires the lock.
     *
     * <p>Acquires the lock if it is not held by another thread and returns
     * immediately, setting the lock hold count to one.
     *
     * <p>If the current thread already holds the lock then the hold
     * count is incremented by one and the method returns immediately.
     *
     * <p>If the lock is held by another thread then the
     * current thread becomes disabled for thread scheduling
     * purposes and lies dormant until the lock has been acquired,
     * at which time the lock hold count is set to one.
     */
    public void lock() {
        sync.lock();
    }

下面参考一下FairSync和NonfairSync对lock方法的实现:

    /**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }
    }

    /**
     * Sync object for fair locks
     */
    static final class FairSync extends Sync {
        final void lock() {
            acquire(1);
        }
    }

当使用非公平锁的时候,会立刻尝试配置状态,成功了就会插队执行,失败了就会和公平锁的机制一样,调用acquire()方法,以排他的方式来获取锁,成功了立刻返回,否则将线程加入队列,知道成功调用为止。

总结

上锁的过程本身也是有时间开销的,如果操作资源的时间比上锁的时间还短建议使用非公平锁可以提高系统的吞吐率;否则就老老实实的用公平锁。

最后

欢迎大家关注我的公种浩【程序员追风】,2019年多家公司java面试题整理了1000多道400多页pdf文档,文章都会在里面更新,整理的资料也会放在里面。
喜欢文章记得关注我点个赞哟,感谢支持!

原文地址:https://www.cnblogs.com/zhuifeng523/p/12036869.html

时间: 2024-10-09 22:26:20

带你快速了解Java锁中的公平锁与非公平锁的相关文章

【视频+图文】带你快速掌握Java中含continue语句的双重for循环

双重for循环掌握后,我们就一起来看看双重for循环的进阶内容一之带continue语句的双重for循环. 上期双重for循环[视频+图文]讲解传输门:点击这里可去小乔的哔哩哔哩观看for循环视频~ 带continue语句的双重for循环[视频+图文] continue语句能用在哪?它的作用是什么? 用法:只能用在循环结构中(for循环,while循环,do-while循环,for each循环) 作用:本次循环体中的continue语句之后代码不执行,直接跳到下次循环. 例子:(ps:看到这里

【视频+图文】带你快速掌握Java中含break语句的双重for循环

双重for循环掌握后,我们就一起来看看双重for循环的进阶内容一之带break语句的双重for循环. 双重for循环[视频+图文]讲解传输门:点击这里可去小乔的哔哩哔哩观看~ 带continue语句的双重for循环[视频+图文]讲解传输门:点击这里可去小乔的哔哩哔哩观看~ 带break语句的双重for循环[视频+图文] break语句能用在哪?它的作用是什么?与continue语句的区别是什么? 用法:能用在循环结构中(for循环,while循环,do-while循环,for each循环)和s

java 加密中使用base64来保证非ascii码字符串的完整性

首先,我们来看一个例子: byte[] b=new byte[]{2,9,43}; String ss=new String(b,"utf-8"); byte[] b1=ss.getbytes(); 这种情况下,b和b1字节数组是相同的. 那下面这种情况呢? byte[] b=new byte[]{-2,-9,43}; String ss=new String(b,"utf-8"); byte[] b1=ss.getbytes(); 打印出来的ss是一堆我们看不懂的

Java并发编程系列之十六:Lock锁

Lock锁简介 Lock锁机制是JDK 5之后新增的锁机制,不同于内置锁,Lock锁必须显式声明,并在合适的位置释放锁.Lock是一个接口,其由三个具体的实现:ReentrantLock.ReetrantReadWriteLock.ReadLock 和 ReetrantReadWriteLock.WriteLock,即重入锁.读锁和写锁.增加Lock机制主要是因为内置锁存在一些功能上局限性.比如无法中断一个正在等待获取锁的线程,无法在等待一个锁的时候无限等待下去.内置锁必须在释放锁的代码块中释放

Java 编程中关于异常处理的 10 个最佳实践

异常处理是书写 强健 Java应用的一个重要部分.它是关乎每个应用的一个非功能性需求,是为了优雅的处理任何错误状况,比如资源不可访问,非法输入,空输入等等.Java提供了几个异常处理特性,以try,catch和finally 关键字的形式内建于语言自身之中.Java编程语言也允许你创建新的异常,并通过使用  throw 和 throws关键字抛出它们.事实上,异常处理不仅仅是知道语法.书写一个强健的代码更多的是一门艺术而不仅仅是一门科学,这里我们将讨论一些关于异常处理的Java最佳实践.这些 J

锁的公平与非公平

锁是给线程用的,线程拿到锁之后才能干活.当多个线程竞争一个锁时,同一个时间只能有一个线程脱颖而出持有锁,其他线程等该线程释放锁后发起下一轮竞争.那么这种竞争就存在公平性问题,如果是公平的竞争,那么这些线程就得有序来依次得到锁,这就需要线程们按先来后到排队,第一个线程使用完后把锁递给第二个线程,以此类推.非公平的锁是无序的,举个例子:线程甲持有锁,后面线程乙跑过来争,发现被甲拿了就去睡觉(休眠或者被挂起)了,等线程甲释放锁通知乙来取:过了会儿,乙被唤醒时,刚好线程丙半路杀过来了,把锁拿去用了,而乙

理解ReentrantLock的公平锁和非公平锁

学习AQS的时候,了解到AQS依赖于内部的FIFO同步队列来完成同步状态的管理,当前线程获取同步状态失败时,同步器会将当前线程以及等待状态等信息构造成一个Node对象并将其加入到同步队列,同时会阻塞当前线程,当同步状态释放时,会把首节点中的线程唤醒,使其再次尝试获取同步状态. 这时,我有了一个疑问,AQS的同步队列是FIFO的,就是先来排队的先走.那怎么实现非公平锁呢?查阅了一些资料,总算知道了. 首先从公平锁开始看起. ReentrantLock 的公平锁 ReentrantLock 默认采用

Java线程中锁的问题

Java线程中锁的问题: 同步代码块的锁是自己定义的类:object obj = new object 同步方法的锁是this 静态同步方法的锁是类名.class

Java 打印金字塔 or 打印带数字的金字塔 (Java 学习中的小记录)

Java 打印金字塔 or 打印带数字的金字塔 (Java 学习中的小记录) 作者:王可利(Star·星星) 效果图: 代码如下: 1 class Star8 2 { 3 public static void main(String[] args) 4 { 5 /* 空格 6 * 1 2*i-1 3 4-1 4-i 7 *** 3 2 4-2 8 ***** 5 1 4-3 9 ******* 7 0 4-4 10 */ 11 //第一层循环控制的是行数 12 for(int i = 1;i<=