关于java:Java-读写锁-ReadWriteLock-原理与应用场景详解

Java并发编程提供了读写锁,次要用于读多写少的场景,明天我就重点来解说读写锁的底层实现原理@mikechen

什么是读写锁?

读写锁并不是JAVA所特有的读写锁(Readers-Writer Lock)顾名思义是一把锁分为两局部:读锁和写锁,其中读锁容许多个线程同时取得,因为读操作自身是线程平安的,而写锁则是互斥锁,不容许多个线程同时取得写锁,并且写操作和读操作也是互斥的。

所谓的读写锁(Readers-Writer Lock),顾名思义就是将一个锁拆分为读锁和写锁两个锁。

其中读锁容许多个线程同时取得,而写锁则是互斥锁,不容许多个线程同时取得写锁,并且写操作和读操作也是互斥的。

为什么须要读写锁?

Synchronized 和 ReentrantLock 都是独占锁,即在同一时刻只有一个线程获取到锁。

然而在有些业务场景中,咱们大多在读取数据,很少写入数据,这种状况下,如果仍应用独占锁,效率将及其低下。

针对这种状况,Java提供了读写锁——ReentrantReadWriteLock。

次要解决:对共享资源有读和写的操作,且写操作没有读操作那么频繁的场景。

读写锁的特点

  • 公平性:读写锁反对非偏心和偏心的锁获取形式,非偏心锁的吞吐量优于偏心锁的吞吐量,默认结构的是非偏心锁
  • 可重入:在线程获取读锁之后可能再次获取读锁,然而不能获取写锁,而线程在获取写锁之后可能再次获取写锁,同时也能获取读锁
  • 锁降级:线程获取写锁之后获取读锁,再开释写锁,这样实现了写锁变为读锁,也叫锁降级

\

读写锁的应用场景

ReentrantReadWriteLock适宜读多写少的场景:

读锁ReentrantReadWriteLock.ReadLock能够被多个线程同时持有, 所以并发能力很高。

写锁ReentrantReadWriteLock.WriteLock是独占锁, 在一个线程持有写锁时候, 其余线程都不能在抢占, 蕴含抢占读锁都会阻塞。

ReentrantReadWriteLock的应用场景总结:其实就是 读读并发、读写互斥、写写互斥而已,如果一个对象并发读的场景大于并发写的场景,那就能够应用 ReentrantReadWriteLock来达到保障线程平安的前提下进步并发效率。

读写锁的次要成员和结构图

1. ReentrantReadWriteLock的继承关系\

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading.
     */
    Lock readLock();
    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing.
     */
    Lock writeLock();
}

读写锁 ReadWriteLock

读写锁保护了一对相干的锁,一个用于只读操作,一个用于写入操作。

只有没有写入,读取锁能够由多个读线程同时放弃,写入锁是独占的。

2.ReentrantReadWriteLock的外围变量\
\
ReentrantReadWriteLock类蕴含三个外围变量:

  1. ReaderLock:读锁,实现了Lock接口
  2. WriterLock:写锁,也实现了Lock接口
  3. Sync:继承自AbstractQueuedSynchronize(AQS),能够为偏心锁FairSync 或 非偏心锁NonfairSync

3.ReentrantReadWriteLock的成员变量和构造函数

 /** 外部提供的读锁 */

    private final ReentrantReadWriteLock.ReadLock readerLock;

    /** 外部提供的写锁 */
    private final ReentrantReadWriteLock.WriteLock writerLock;

    /** AQS来实现的同步器 */
    final Sync sync;

    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * 默认创立非偏心的读写锁
     */
    public ReentrantReadWriteLock() {
        this(false);
    }

    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * the given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

读写锁的实现原理

ReentrantReadWriteLock实现关键点,次要包含:

  • 读写状态的设计
  • 写锁的获取与开释
  • 读锁的获取与开释
  • 锁降级

1.读写状态的设计

之前谈ReentrantLock的时候,Sync类是继承于AQS,次要以int state为线程锁状态,0示意没有被线程占用,1示意曾经有线程占用。

同样ReentrantReadWriteLock也是继承于AQS来实现同步,那int state怎么同时来辨别读锁和写锁的?

如果在一个整型变量上保护多种状态,就肯定须要“按位切割应用”这个变量,ReentrantReadWriteLock将int类型的state将变量切割成两局部:

  • 高16位记录读锁状态
  • 低16位记录写锁状态
abstract static class Sync extends AbstractQueuedSynchronizer {
    // 版本序列号
    private static final long serialVersionUID = 6317671515068378041L;        
    // 高16位为读锁,低16位为写锁
    static final int SHARED_SHIFT   = 16;
    // 读锁单位
    static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
    // 读锁最大数量
    static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
    // 写锁最大数量
    static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
    // 本地线程计数器
    private transient ThreadLocalHoldCounter readHolds;
    // 缓存的计数器
    private transient HoldCounter cachedHoldCounter;
    // 第一个读线程
    private transient Thread firstReader = null;
    // 第一个读线程的计数
    private transient int firstReaderHoldCount;
}

2.写锁的获取与开释

protected final boolean tryAcquire(int acquires) {
            /*
             * Walkthrough:
             * 1. If read count nonzero or write count nonzero
             *    and owner is a different thread, fail.
             * 2. If count would saturate, fail. (This can only
             *    happen if count is already nonzero.)
             * 3. Otherwise, this thread is eligible for lock if
             *    it is either a reentrant acquire or
             *    queue policy allows it. If so, update state
             *    and set owner.
             */
            Thread current = Thread.currentThread();
            int c = getState();
            //获取独占锁(写锁)的被获取的数量
            int w = exclusiveCount(c);
            if (c != 0) {
                // (Note: if c != 0 and w == 0 then shared count != 0)
                //1.如果同步状态不为0,且写状态为0,则示意以后同步状态被读锁获取
                //2.或者以后领有写锁的线程不是以后线程
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
                if (w + exclusiveCount(acquires) > MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
                // Reentrant acquire
                setState(c + acquires);
                return true;
            }
            if (writerShouldBlock() ||
                !compareAndSetState(c, c + acquires))
                return false;
            setExclusiveOwnerThread(current);
            return true;
        }

1)c是获取以后锁状态,w是获取写锁的状态。

2)如果锁状态不为零,而写锁的状态为0,则示意读锁状态不为0,所以以后线程不能获取写锁。或者锁状态不为零,而写锁的状态也不为0,然而获取写锁的线程不是以后线程,则以后线程不能获取写锁。

3)写锁是一个可重入的排它锁,在获取同步状态时,减少了一个读锁是否存在的判断。

写锁的开释与ReentrantLock的开释过程相似,每次开释将写状态减1,直到写状态为0时,才示意该写锁被开释了。

3.读锁的获取与开释

protected final int tryAcquireShared(int unused) {
    for(;;) {
        int c = getState();
        int nextc = c + (1<<16);
        if(nextc < c) {
           throw new Error("Maxumum lock count exceeded");
        }
        if(exclusiveCount(c)!=0 && owner != Thread.currentThread())
           return -1;
        if(compareAndSetState(c,nextc))
           return 1;
    }
}

1)读锁是一个反对重进入的共享锁,能够被多个线程同时获取。

2)在没有写状态为0时,读锁总会被胜利获取,而所做的也只是减少读状态(线程平安)

3)读状态是所有线程获取读锁次数的总和,而每个线程各自获取读锁的次数只能抉择保留在ThreadLocal中,由线程本身保护。

读锁的每次开释均减小状态(线程平安的,可能有多个读线程同时开释锁),减小的值是1<<16。


4.锁降级

降级是指以后把持住写锁,再获取到读锁,随后开释(先前领有的)写锁的过程。

锁降级过程中的读锁的获取是否有必要,答案是必要的。次要是为了保证数据的可见性,如果以后线程不获取读锁而间接开释写锁,假如此刻另一个线程获取的写锁,并批改了数据,那么以后线程就步调感知到线程T的数据更新,如果以后线程遵循锁降级的步骤,那么线程T将会被阻塞,直到以后线程使数据并开释读锁之后,线程T能力获取写锁进行数据更新。


5.读锁与写锁的整体流程\

读写锁总结

本篇具体介绍了ReentrantReadWriteLock的特色、实现、锁的获取过程,通过4个关键点的外围设计:

  • 读写状态的设计
  • 写锁的获取与开释
  • 读锁的获取与开释
  • 锁降级

从而能力实现:共享资源有读和写的操作,且写操作没有读操作那么频繁的利用场景。

作者简介

陈睿|mikechen,10年+大厂架构教训,《BAT架构技术500期》系列文章作者,专一于互联网架构技术。

浏览mikechen的互联网架构更多技术文章合集

Java并发|JVM|MySQL|Spring|Redis|分布式|高并发

关注「mikechen 的互联网架构」公众号,回复 【架构】 支付《Java进阶架构思维导图&Java进阶架构文章合集》

【腾讯云】轻量 2核2G4M,首年65元

阿里云限时活动-云数据库 RDS MySQL  1核2G配置 1.88/月 速抢

本文由乐趣区整理发布,转载请注明出处,谢谢。

您可能还喜欢...

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注

此站点使用Akismet来减少垃圾评论。了解我们如何处理您的评论数据