Android高工进阶必会技能——synchronized锁升级与降圾-六虎

敞开生长之旅！这是我参加「日新计划 12 月更文挑战」的第28天，点击检查活动详情

背景

synchronized是Java完成同步的一种机制，它属于Java中关键字，是一种jvm等级的锁。synchronized锁的创立和开释是此关键字控制的代码的开始和完毕位置，锁是有jvm控制的创立和开释的，正是由于这一点，synchronized锁不需求手动开释，哪怕是代码呈现反常，jvm也能主动开释锁。一起jvm也记载的运用锁的线程，以及哪些线程呈现了死锁这十分有利于咱们排查问题。

运用优缺点

长处

　　1.synchronized所不必手动开释锁，即便抛出反常jvm也是让线程主动开释锁

　　2.当 JVM 用 synchronized 管理确定请求和开释时，JVM 在生成线程转储时能够包含确定信息。这些对调试十分有价值，由于它们能标识死锁或许其他反常行为的来源

缺点

　　1.运用synchronized假如其中一个线程不开释锁，那么其他需求获取锁的线程会一向等候下去，等候的线程不能中途中断，直到运用完开释或许呈现反常jvm会让线程主动开释锁

　　2.也无法经过投票得到锁，假如不想等下去，也就无法得到锁

　　3.同步还要求锁的开释只能在与取得锁地点的仓库帧相同的仓库帧中进行，多数情况下，这没问题（而且与反常处理交互得很好），可是，的确存在一些非块结构的确定更合适的情况　　4.在剧烈争用情况下更佳的性能,也即是假如多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等候无法进行读操作，性能比较低。由于当 JVM 用 synchronized 管理确定请求和开释时，JVM 在生成线程转储时能够包含确定信息，这些虽然对调试十分有价值，由于它们能标识死锁或许其他反常行为的来源，可是这势必会增大资源的耗费和耗时增加。

Synchronized锁晋级、降级原理

多线程中锁的晋级

synchronized锁晋级原理:在锁目标的目标头里面有一个threadid字段，在第一次访问的时分threadid为空，jvm 让其持有倾向锁，并将threadid 设置为其线程id，再次进入的时分会先判别threadid是否与其线程id共同。

假如共同则能够直接运用此目标，假如不共同，则晋级倾向锁为轻量级锁，经过自旋循环必定次数来获取锁，履行必定次数之后，假如还没有正常获取到要运用的目标，此刻就会把锁从轻量级晋级为重量级锁，此进程就构成了synchronized 锁的晋级。

锁的晋级的意图

锁晋级是为了减低了锁带来的性能耗费。在Java 6之后优化 synchronized的完成方式，运用了倾向锁晋级为轻量级锁再晋级到重量级锁的方式，然后减低了锁带来的性能耗费。

多线程中锁的降级

我注意到有的观点以为Java不会进行锁降级。实际上据我所知，锁降级的确是会发生的。

详细的触发时机:在大局安全点(safepoint）中，履行清理任务的时分会触发测验降级锁。当锁降级时，首要进行了以下操作:

恢复锁目标的markword目标头;
重置ObjectMonitor，然后将该ObjectMonitor放入大局闲暇列表，等候后续运用。

拓宽常识

Java目标在堆内存的构成

在JVM中，目标在堆内存中分为三块区域：

（1）目标头

目标头相当于目标的元数据信息，目标头由两部分组成：

（a）Mark Word（符号字段）

存储目标的HashCode、分代年纪和锁标志位信息，在运转期间Mark Word里存储的数据结构会跟着锁标志位的改变而改变，Mark Word的结构图如下，图摘自链接3：

Mark Word结构图

上面提到了Mark Word被设计成一个非固定结构，在运转期间会跟着锁标志位的改变而改变，上图中一个锁标志位地点的一行数据结构就对应一种Mark Word结构。

（b）Klass Pointer（类型指针）

目标指向它的类元数据的指针，JVM经过这个指针来确定目标是哪个类的实例。

（2）实例数据

这部分首要存放类的数据信息和父类信息。

（3）填充数据

JVM要求目标的起始地址有必要是8字节的整数倍，填充数据不是有必要存在的，只是是为了字节对齐。

synchronized锁晋级流程

synchronized锁/重量级锁

这儿首要介绍一下一般说的synchronized锁或许重量级锁的底层完成原理

Monitor目标

咱们经常说synchronized关键字取得的是一个目标锁，那这个目标锁到底是什么？

每一个目标的目标头会关联一个Monitor目标，这个Monitor目标的完成底层是用C++写的，对应在虚拟机里的ObjectMonitor.hpp文件中。

Monitor目标由以下3部分组成：

（1）EntryList行列

当多个线程一起访问一个Monitor目标时，这些线程会先被放进EntryList行列，此刻这些线程处于Blocked情况；

（2）Owner

当一个线程获取到了这个Monitor目标时，Owner会指向这个线程，当线程开释掉了Monitor目标时，Owner会置为null；

（3）WaitSet行列

当线程调用wait办法时，当时线程会开释目标锁，一起该线程进入WaitSet行列。

Monitor目标还有一个计数器count的概念，这个count是属于Monitor目标的，而不属于某个取得了Monitor目标的线程，当Monitor目标被某个线程获取时，++count，当Monitor目标被某个线程开释时，–count。

同步代码块和同步办法

synchronized关键字能够润饰办法，也能够润饰代码块，二者底层的完成稍有不同。

（1）同步代码块

public void method(){    synchronized(new Object()){     do something...     }   }

当进入method办法的synchronized代码块时，经过monitorenter指令取得Monitor目标的一切权，此刻count+1，Monitor目标的owner指向当时线程；
假如当时线程现已是Monitor目标的owner了，再次进入synchronized代码块时，会将count+1；
当线程履行完synchronized代码块里的内容后，会履行monitorexit，对应的count-1，直到count为0时，才以为Monitor目标不再被线程占有，其他线程才能够测验获取Monitor目标。

（2）同步办法

当线程调用到办法时，会判别一个标志位：ACC_SYNCHRONIZED。当办法是同步办法时，会有这个标志位，ACC_SYNCHRONIZED会去隐式调用那两个指令：monitorenter和monitorexit去取得和开释Monitor目标。

归根到底，synchronized关键字仍是看哪个线程取得了目标对应的Monitor目标。

锁晋级进程

JDK1.6之前，synchronized的完成涉及到操作系统完成线程之间的切换时需求从用户态切换为核心态，这是很耗费资源的，这也是早期synchronized锁称为“重量级”锁的原因，jdk1.6之后对synchronized锁进行了优化，引进了倾向锁和轻量级锁的概念，即synchronized锁有详细4种情况，这几个情况会跟着竞赛程度逐渐晋级，便是锁晋级。

synchronized锁的4种情况

synchronized锁有无锁、倾向锁、轻量级锁和重量级锁4种情况，在目标头的Mark Word里有展现，锁情况不同，Mark Word的结构也不同。

（1）无锁

很好理解，便是不存在竞赛，线程没有获取synchronized锁的情况。

（2）倾向锁

即倾向第一个拿到锁的线程，锁会在目标头的Mark Word经过CAS（Compare And Swap）记载取得锁的线程id，一起将Mark Word里的锁情况置为倾向锁，是否为倾向锁的位也置为1，当下一次仍是这个线程获取锁时就不需求经过CAS。

假如其他的线程测验经过CAS获取锁（即想将目标头的Mark Word中的线程ID改成自己的）会获取失利，此刻锁由倾向锁晋级为轻量级锁。

（3）轻量级锁

JVM会给线程的栈帧中创立一个锁记载（Lock Record）的空间，将目标头的Mark Word拷贝到Lock Record中，并测验经过CAS把原目标头的Mark Word中指向锁记载的指针指向当时线程中的锁记载，假如成功，表明线程拿到了锁。假如失利，则进行自旋（自旋锁），自旋超越必定次数时晋级为重量级锁，这时该线程会被内核挂起。

（4）自旋锁

轻量级锁晋级为重量级锁之前，线程履行monitorenter指令进入Monitor目标的EntryList行列，此刻会经过自旋测验取得锁，假如自旋次数超越了必定阈值（默许10），才会晋级为重量级锁，等候线程被唤起。

线程等候唤起的进程涉及到Linux系统用户态和内核态的切换，这个进程是很耗费资源的，自选锁的引进正是为了处理这个问题，先不让线程立马进入堵塞情况，而是先给个机会自旋等候一下。

（5）重量级锁

在2中现已介绍，便是一般说的synchronized重量级锁。

锁晋级进程

锁晋级的次序为：

无锁 -> 倾向锁 -> 轻量级锁 -> 重量级锁，且锁晋级的次序是不可逆的。

线程第一次获取锁获时锁的情况为倾向锁，假如下次仍是这个线程获取锁，则锁的情况不变，不然会晋级为CAS轻量级锁；假如还有线程竞赛获取锁，假如线程获取到了轻量级锁没啥事了，假如没获取到会自旋，自旋期间获取到了锁没啥事，超越了10次还没获取到锁，锁就晋级为重量级的锁，此刻假如其他线程没获取到重量级锁，就会被堵塞等候唤起，此刻效率就低了。

详细次序如图所示：

锁晋级进程

synchronized锁降级流程

锁降级概念

锁降级:当时线程取得写锁,没有开释写锁的情况下再去取得读锁,然后开释写锁,这个进程便是锁降级 (当时线程持有锁的情况由写锁降到读锁便是锁降级)

运用场景:当多线程情况下，更新完数据要立刻查询刚更新完的数据 (因更新完数据开释写锁后还持有读锁，一切线程要取得写锁都要等候读锁开释,这时持有读锁的线程能够查到刚更新完的数据)

坏处:适合读多写少的场景,假如锁降级的一起设置成了非公正锁可能会导致写锁很长时间取得不到

ReentrantReadWriteLock

ReentrantReadWriteLock支持锁降级,可是不支持锁晋级下面代码阐明ReentrantReadWriteLock锁降级的运用

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockDemo {

   //默许是非公正锁
   //ReentrantReadWriteLock 支持锁降级 不支持锁晋级
   ReentrantReadWriteLock reentrantReadWriteLock=new ReentrantReadWriteLock(true);
   //读锁
   ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
   //写锁
   ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
  
   private  int i=0;
  
   public static void main(String[] args) {
  
     //锁晋级  当时线程持有读锁,然后取得写锁,将读锁开释,这样就完成了锁晋级
     //锁降级  当时线程持有写锁,然后取得读锁,将写锁开释,这样就完成了锁降级

//锁降级
//     writeLock.lock();
//     System.out.println("取得写锁");
//     readLock.lock();
//     System.out.println("取得读锁");
//     writeLock.unlock();
//     System.out.println("取得开释写锁");
//     readLock.unlock();
//     System.out.println("开释读锁");

//锁晋级 （ReentrantReadWriteLock 不支持锁晋级）在持有读锁情况下取得写锁会堵塞,要等候读锁开释
//     readLock.lock();
//     System.out.println("取得读锁");
//     writeLock.lock();
//     System.out.println("取得写锁");
//     readLock.unlock();
//     System.out.println("开释读锁");
//     writeLock.unlock();
//     System.out.println("取得开释写锁");
     //为了处理敏感数据才会运用锁降级
     ReentrantReadWriteLockDemo myCountDownLatch=new ReentrantReadWriteLockDemo();
     for(int i=0;i<5;i++){
       new Thread(()->{
         myCountDownLatch.doSomething();
       }).start();
     }
   }

   public void doSomething(){
     try{
       writeLock.lock();
       i++;
       writeLock.lock();
     }finally {
       writeLock.unlock();
     }
     try {
       //模拟复杂事务
       Thread.sleep(2000L);
     } catch (InterruptedException e) {
       e.printStackTrace();
     }
  
     try{
       //假如每次更新后的数据都要查询
       //数据比较敏感能够运用所降级
       //writeLock.lock();
       System.out.println(i);
     }finally {
       writeLock.unlock();
     }
   }
}

ReentrantReadWriteLock 浅析

ReentrantReadWriteLock 什么情况下能取得锁

ReentrantReadWriteLock 有两把锁,一个是读锁一个是写锁当A线程取得到写锁没有开释时,其他线程想取得读锁只能堵塞,然而这时A线程能够再次取得写锁和读锁。

当A线程取得到读锁没有开释时,其他线程也能取得读锁,这时A线程和其他线程想取得写锁都要堵塞。

ReentrantReadWriteLock 读锁和写锁重入次数核算

ReentrantReadWriteLock 类中有一个Sync静态内部类，Sync类中代码阐明将一个int 32位的数拆分成两个无符号位的short类型，其中这个数的低16位表明写锁个数,高16位表明读锁个数,所以得出读锁或写锁的重入次数最大是65535次 Sync代码如下

  abstract static class Sync extends AbstractQueuedSynchronizer {
     private static final long serialVersionUID = 6317671515068378041L;
     /*
     * Read vs write count extraction constants and functions.
     * Lock state is logically divided into two unsigned shorts:
     * The lower one representing the exclusive (writer) lock hold count,
     * and the upper the shared (reader) hold count.
     */
     static final int SHARED_SHIFT  = 16;
     //1左移16位 是 65536  => 0000 0000 0000 0001 0000 0000 0000 0000
     static final int SHARED_UNIT   = (1 << SHARED_SHIFT);
     //1左移16位 是 65535 ⇒ 0000 0000 0000 0000 1111 1111 1111 1111
     static final int MAX_COUNT    = (1 << SHARED_SHIFT) - 1;
     static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

     /** Returns the number of shared holds represented in count  */
     //无符号右移16位  回来读锁的个数 
     static int sharedCount(int c)   { return c >>> SHARED_SHIFT; }
     /** Returns the number of exclusive holds represented in count  */
     //int类型数据 与 0000 0000 0000 0000 1111 1111 1111 1111
     //回来写锁的个数
     static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }
     }

ReentrantReadWriteLock 读锁上锁代码分析

简化代码履行流程，代码如下


 public void lock() {
    //取得读锁
    //这儿传入的值为1,由于假如当时线程持有读锁这儿重入次数要加1或得到锁重入次数初始化为1
    //这儿会调用抽象类AbstractQueuedSynchronizer中的办法
    sync.acquireShared(1);
 }

 public final void acquireShared(int arg) {
        //测验去取得锁,假如没有取得到锁回来值会小于0
        //调用ReentrantReadWriteLock中重写的办法
     if (tryAcquireShared(arg) < 0)
         //当取得到锁没有取得到履行此办法
       doAcquireShared(arg);
 }

//来到ReentrantReadWriteLock中
protected final int tryAcquireShared(int unused) {
    /*
     * Walkthrough:
     * 1. If write lock held by another thread, fail.
     * 2. Otherwise, this thread is eligible for
     *   lock wrt state, so ask if it should block
     *   because of queue policy. If not, try
     *   to grant by CASing state and updating count.
     *   Note that step does not check for reentrant
     *   acquires, which is postponed to full version
     *   to avoid having to check hold count in
     *   the more typical non-reentrant case.
     * 3. If step 2 fails either because thread
     *   apparently not eligible or CAS fails or count
     *   saturated, chain to version with full retry loop.
     */
    Thread current = Thread.currentThread();
    //这个变量中存储着,读锁的重入次数和写锁的重入次数
    int c = getState();
    //假如有线程持有写锁并且不是自己持有的则直接回来-1 阐明没有取得到锁
    if (exclusiveCount(c) != 0 &&
        getExclusiveOwnerThread() != current)
        return -1;
    //取得读锁个数
    int r = sharedCount(c);
    //判别是否应该堵塞,由于这儿分析的是读锁,来到ReentrantReadWriteLock 的ReadLock内部类的readerShouldBlock办法中
    if (!readerShouldBlock() && 
       //判别重入次数是否小于65536
        r < MAX_COUNT &&
        //运用cas将读锁重入次数加1 
        //SHARED_UNIT是65536,由于读锁重入次数是高16位所以这儿要加65536
        compareAndSetState(c, c + SHARED_UNIT)) {
        //读锁的重入次数为0,则本次取得读锁的是第一个
        if (r == 0) {
           //将持有锁的线程设置成为当时线程
            firstReader = current;
            //设置读锁的重入次数为1
            firstReaderHoldCount = 1;
        } else if (firstReader == current) {
           //假如现已是当时线程持有锁了,则直接重入次数+1
            firstReaderHoldCount++;
        } else {
           //rh中存储着当时线程的id,和一个count
            HoldCounter rh = cachedHoldCounter;
            //假如当时变量没有缓存或 ThreadLocal中的线程id和当时线程的id不同
            //这儿不能运用thread.getId() 是由于getId()办法不是final的
            if (rh == null || rh.tid != getThreadId(current))
               //readHolds是会在ReentrantReadWriteLock 的内部类Sync中初始化(在Sync构造办法中初始化的)
               //readHolds创立时分经过ThreadLocal将HoldCounter存到当时线程中
               //HoldCounter中存了领先线程的pid和一个count
               //取得到rh 然后给cachedHoldCounter 用来缓存
                cachedHoldCounter = rh = readHolds.get();
            //第一次获取HoldCounter的时分,rh的count肯定是0,取得了之后就会存到缓存中
            //意思是假如缓存中没有,count肯定是0
            else if (rh.count == 0)
                readHolds.set(rh);
            rh.count++;
        }
        return 1;
    }
    //从头循环去取得锁,可是假如重入次数超越65535则会抛出反常
    return fullTryAcquireShared(current);
}

//当取得到锁没有取得到履行此办法
private void doAcquireShared(int arg) {
        //Node.SHARED是一个空节点
        //创立一个节点,节点中存着当时线程,然后将这个节点经过cas添加到一个双向链表中
        //1 假如行列中没有一个节点,这是会将行列中的头结点和尾节点都设置添加的节点
        //2 假如行列中有节点,则经过cas将添加的节点设置成尾节点
        //回来添加到行列中的节点
     final Node node = addWaiter(Node.SHARED);
     boolean failed = true;
     try {
       boolean interrupted = false;
       for (;;) {
         //找到当时节点的上一个节点
         final Node p = node.predecessor();
         //假如上一个节点是第一个节点
         if (p == head) {
             //测验去取得读锁
           int r = tryAcquireShared(arg);
           //取得到了读锁
           if (r >= 0) {          
               //将头节点设置成为自己,然后调用LockSupport.unpark(s.thread) 履行本线程
             setHeadAndPropagate(node, r);
             p.next = null; // help GC
             if (interrupted)
               selfInterrupt();
             failed = false;
             return;
           }
         }
         //判别本节点和上一个节点的情况
         if (shouldParkAfterFailedAcquire(p, node) &&
           //在这儿履行LockSupport.park(this); 堵塞当时线程
           parkAndCheckInterrupt())
           interrupted = true;
       }
   } finally {
       //假如当时Node存储的线程还没有履行LockSupport.unpark(s.thread) 则履行cancelAcquire
       if (failed)
         cancelAcquire(node);
   }
}

总结

所谓的锁晋级、降级，便是 JVM 优化 synchronized 运转的机制，当 JVM 监测到不同的竞赛情况是，会主动切换到不同的锁完成。这种切换便是锁的晋级、降级。

Android高工进阶必会技能——synchronized锁升级与降圾

背景

运用优缺点

长处

缺点

Synchronized锁晋级、降级原理

多线程中锁的晋级

锁的晋级的意图

多线程中锁的降级

拓宽常识

Java目标在堆内存的构成

synchronized锁晋级流程

synchronized锁/重量级锁

Monitor目标

（1）EntryList行列

（2）Owner

（3）WaitSet行列

同步代码块和同步办法

（1）同步代码块

（2）同步办法

锁晋级进程

synchronized锁的4种情况

（1）无锁

（2）倾向锁

（3）轻量级锁

（4）自旋锁

（5）重量级锁

锁晋级进程

synchronized锁降级流程

锁降级概念

ReentrantReadWriteLock

ReentrantReadWriteLock 浅析

ReentrantReadWriteLock 什么情况下能取得锁

ReentrantReadWriteLock 读锁和写锁重入次数核算

ReentrantReadWriteLock 读锁上锁代码分析

总结

相关文章

git 稀疏检出和部分克隆

JUnit 5测试中的临时目录（附实例及代码）

Dagger2注解大全

欢迎来到 Python 的世界，已开通笔记&功能实践的双进程【玩转 Python】

作者信息