写点什么

回眸重探锁机制 (1),零基础 android

用户头像
Android架构
关注
发布于: 刚刚

6.2 独占锁

6.2.1 获取资源

可以通过下面几种方法来获取


  • void acquire(int arg):获取锁,arg 一般来说是 1


public final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}


  • void acquireInterruptibly(int arg):获取锁,抛出打断异常


public final void acquireInterruptibly(int arg)throws InterruptedException {if (Thread.interrupted())throw new InterruptedException();if (!tryAcquire(arg))doAcquireInterruptibly(arg);}


  • boolean tryAcquireNanos(int arg, long nanosTimeout):获取锁存在最长时间,抛出打断异常


public final boolean tryAcquireNanos(int arg, long nanosTimeout)throws InterruptedException {if (Thread.interrupted())throw new InterruptedException();return tryAcquire(arg) ||doAcquireNanos(arg, nanosTimeout);}


可见,如果 tryAcquire 返回 true 时,相应方法也就结束了,线程后续方法即可继续执行,也就是获取锁了;而如果返回 false 时,后面方法则很大可能会触发线程暂停


protected boolean tryAcquire(int arg) {throw new UnsupportedOperationException();}


tryAcquire 方法需要用户自实现;现有锁都是通过 AQS 中 state 整数变量来实现的

6.2.2 释放资源

public final boolean release(int arg) {if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}return false;}


这里 tryRelease 返回 true 时,才有可能通知其它线程去竞争资源;


protected boolean tryRelease(int arg) {throw new UnsupportedOperationException();}


需要用户自实现;现有锁都是通过 AQS 中 state 整数变量来实现的

6.3 独占锁

6.3.1 获取资源

同样存在不同的入口


  • void acquireShared(int arg):获取共享锁


public final void acquireShared(int arg) {if (tryAcquireShared(arg) < 0)doAcquireShared(arg);}


  • void acquireSharedInterruptibly(int arg):获取共享锁,会抛出打断异常


public final void acquireSharedInterruptibly(int arg) throws InterruptedException {if (Thread.interrupted())throw new InterruptedException();if (tryAcquireShared(arg) < 0)doAcquireSharedInterruptibly(arg);}


  • boolean tryAcquireSharedNanos(int arg, long nanosTimeout):获取锁有时间限制,超过则结束返回是否获取成功;会抛出打断异常


public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {if (Thread.interrupted())throw new InterruptedException();return tryAcquireShared(arg) >= 0 || doAcquireSharedNanos(arg, nanosTimeout);}


这里获取资源的条件是受 tryAcquireShared 的返回值来控制的,>=0 时,线程继续执行,否则,很可能会线程暂停; tryAcquireShared 方法需要用户实现,也会通过 AQS 中 state 变量来处理


protected int tryAcquireShared(int arg) {throw new UnsupportedOperationException();}

6.3.2 释放资源

释放时也只有一个入口


public final boolean releaseShared(int arg) {if (tryReleaseShared(arg)) {doReleaseShared();return true;}return false;}


tryReleaseShared 返回 true 时,才有可能去唤醒其它线程去竞争资源;也需要用户实现,同样,也是基于 AQS 中 state 变量来控制


protected boolean tryReleaseShared(int arg) {throw new UnsupportedOperationException();}

6.4 可重入

可重入性,是持有资源者,再次自动持有资源的行为;这些在独占锁锁中,只需要线程判断即可,而共享锁,则是不仅仅需要线程判断,还需要一些列共享持有者单独比对,无疑当前线程比对可以优化这个过程;线程的存储 AQS 已经提供方法,这些方法来源于其继承的抽象类 AbstractOwnableSynchronizer,而是否持有,则由方法 isHeldExclusively 提供,而这个方法需要用户实现


protected boolean isHeldExclusively() {throw new UnsupportedOperationException();}

6.5 数据变化

数据变化,涉及到几个重要方法:


  • addWaiter:从双端队列,队尾加入节点;线程获取资源失败时,会生成节点并加入队列;而条件锁在等待唤醒时被唤醒后,通过 enq 方法加入队列

  • shouldParkAfterFailedAcquire:决定是否暂停当前线程,在循环中处理

  • parkAndCheckInterrupt:暂停线程,并返回打断状态且重置打断状态

  • unparkSuccessor:唤醒等待资源的线程,进行资源竞争获取

6.5.1 添加节点

独占资源



共享资源



条件资源


6.5.2 线程执行异常或者被打断

独占资源



共享资源


6.5.3 等待状态

相对于 5.5.2,其中变化的仅仅 waitStatus = -1

6.5.4 条件唤醒状态

这是条件锁特有状态;实现原理是:首先节点在条件单列表条件链表中等待;两个等待循环条件为是否在资源竞争的双向列表中(就是独占/共享的队列),如果被唤醒,其就会在此队列了,然后调用独占锁的逻辑获取锁 其关键方法:


  • isOnSyncQueue:是否存在 AQS 中的双向队列中,被唤醒后存在

  • doSignal:移除条件单向列表列中头节点,并改变状态 waitStatus=0,加入 AQS 双向列表中去

6.6 条件锁使用条件

final int fullyRelease(Node node) {try {int savedState = getState();if (release(savedState))return savedState;throw new IllegalMonitorStateException();} catch (Throwable t) {node.waitStatus = Node.CANCELLED;throw t;}}


这个方法是在获取资源时均会调用的方法;会首先释放 state 个资源使用权,然后通过加入队列后通过相应方法获取 state 个使用权;释放不了 state 个使用权会直接报异常;因此,条件锁使用时,必须在当前已经获取资源使用权的情况使用下,且仅仅只有其自己获取资源使用权;

6.7 小结

其在性能上有许多要学习的地方:比如在获取资源执行权时,并没有立刻去暂停线程;在状态变化过程中,也没有仅仅考虑当前状态,也进行有可能的唤醒线程竞争、去除无效资源等;整体采用自旋+CAS 机制处理;

7 android 中的锁

7.1 synchronized 关键字

上面介绍锁概念时大致介绍了这个关键字,其通过编译时在代码块加入同步指令处理的;是以特


《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
浏览器打开:qq.cn.hn/FTe 免费领取
复制代码


殊的一个对象作为锁的标志:


  • 修饰实例方法,作用于当前实例加锁,进入同步代码前要获得当前实例的锁

  • 修饰静态方法,作用于当前类对象加锁,进入同步代码前要获得当前类对象的锁

  • 修饰代码块,指定加锁对象,对给定对象加锁,进入同步代码库前要获得给定对象的锁。


通过锁对象来实现条件策略;这写方法来源于 Object 的 wait/notify/notifyAll 方法

7.2 ReentrantLock 锁

可重入锁、独占锁;有两种模式:公平、非公平,可通过构造器进行设定;公平不公平,就是在获取资源执行权时,是否按照排队顺序优先获取来定的


公平锁


final void lock() {acquire(1);}


protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {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;}


这里有两种获取锁的方式:


  1. 当前 state=0,AQS 队列中无排队线程,且 CAS 操作 state 成功,则把记录当前线程

  2. 当前线程为上次纪律线程,则把 state 再次增加


为什么公平,就是因为,可获取资源时,先检查当前排队队列是否为空,为空才会获取


非公平锁


final void lock() {if (compareAndSetState(0, 1))setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);}


protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);}


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) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}


获取锁资源成功条件


  1. 对 state 进行 CAS 操作,成功;记录线程

  2. 如果当前资源可被获取也即 state = 0 时,对 state 进行 CAS 操作成功;记录线程

  3. 当前线程为记录线程


唤醒竞争


protected final boolean tryRelease(int releases) {int c = getState() - releases;if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;if (c == 0) {free = true;setExclusiveOwnerThread(null);}setState(c);return free;}


state 为 0 时,才会唤醒其它线程进行竞争;而不为 0 时,只是进行减少,这于可重入处理时相加相对应;所以加锁和解锁要成对出现

7.3 ReentrantReadWriteLock 锁

可重入锁;独占锁和共享锁共存; 读写锁;其读锁调用 AQS 的共享资源方法,写锁调用 AQS 独占资源方法;其也存在两种模式:公平、非公平,可通过构造器进行设定;


公平/非公平模式


  1. 对于写锁,公平时查看当前是否排队的,排队优先,非公平时,尝试获取资源的线程优先

  2. 对于读锁,公平模式时同样查看当前是否有排队的,排队优先,非公平时,根据排队等待的对头是否为独占节点


也即是依靠如下方法:返回 true 表示公平模式


abstract boolean readerShouldBlock();abstract boolean writerShouldBlock()


条件锁


  1. 读锁:直接抛出 UnsupportedOperationException 异常

  2. 写锁:使用 AQS 实现类调用 newCondition 生成


state 状态


读锁,通过 state 的低 16 位来确定个数;写锁通过 state 的高 16 位来确定


独占资源处理


protected final boolean tryRelease(int releases) {if (!isHeldExclusively())throw new IllegalMonitorStateException();int nextc = getState() - releases;boolean free = exclusiveCount(nextc) == 0;if (free)setExclusiveOwnerThread(null);setState(nextc);return free;}


唤醒处理和 ReentrantLock 没有区别


protected final boolean tryAcquire(int acquires) {Thread current = Thread.currentThread();int c = getState();int w = exclusiveCount(c);if (c != 0) {if (w == 0 || current != getExclusiveOwnerThread())return false;if (w + exclusiveCount(acquires) > MAX_COUNT)throw new Error("Maximum lock count exceeded");setState(c + acquires);return true;}if (writerShouldBlock() ||!compareAndSetState(c, c + acquires))return false;setExclusiveOwnerThread(current);return true;}


获取资源时,逻辑如下:


  1. state!=0,而排队的独占节点为 0,或者不为记录线程;则获取失败,这时优先读锁

  2. state!=0,而排队中存在独占节点且为当前线程已经获得执行权,则获取成功

  3. 写公平模式或者 CAS 操作 state 失败,获取失败,否则成功


共享资源处理


这个相对于独占就复杂多了


protected final boolean tryReleaseShared(int unused) {Thread current = Thread.currentThread();if (firstReader == current) {if (firstReaderHoldCount == 1)firstReader = null;elsefirstReaderHoldCount--;} else {HoldCounter rh = cachedHoldCounter;if (rh == null || rh.tid != getThreadId(current))rh = readHolds.get();int count = rh.count;if (count <= 1) {readHolds.remove();if (count <= 0)throw unmatchedUnlockException();}--rh.count;}for (;;) {int c = getState();int nextc = c - SHARED_UNIT;if (compareAndSetState(c, nextc))return nextc == 0;}}


对是否需要唤醒时,首先需要处理共享的数据,然后才是 state 的 CAS 操作且是循环操作


  • 共享数据: firstReader 共享节点的第一个线程对象,firstReader 线程对象对应的重入数目 firstReaderHoldCount;cachedHoldCounter:最后一个共享节点对象线程 tid 和持有重入数目;readHolds 为 HoldCounte 线程存储

  • CAS 循环操作的原因:因为读操作可能同时存在多个,保证 state 的安全


protected final int tryAcquireShared(int unused) {Thread current = Thread.currentThread();int c = getState();if (exclusiveCount(c) != 0 &&getExclusiveOwnerThread() != current)

用户头像

Android架构

关注

还未添加个人签名 2021.10.31 加入

还未添加个人简介

评论

发布
暂无评论
回眸重探锁机制(1),零基础android