15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized

这篇具有很好参考价值的文章主要介绍了15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Synchronized

本篇文章将围绕synchronized关键字,使用大量图片、案例深入浅出的描述CAS、synchronized Java层面和C++层面的实现、锁升级的原理、源码等

大概观看时间17分钟

可以带着几个问题去查看本文,如果认真看完,问题都会迎刃而解:

1、synchronized是怎么使用的?在Java层面是如何实现?

2、CAS是什么?能带来什么好处?又有什么缺点?

3、mark word是什么?跟synchronized有啥关系?

4、synchronized的锁升级优化是什么?在C++层面如何实现?

5、JDK 8 中轻量级锁CAS失败到底会不会自旋?

6、什么是object monitor?wait/notify方法是如何实现的?使用synchronized时,线程阻塞后是如何在阻塞队列中排序的?

...

synchronized Java层面实现

synchronized作用在代码块或方法上,用于保证并发环境下的同步机制

任何线程遇到synchronized都要先获取到锁才能执行代码块或方法中的操作

在Java中每个对象有一个对应的monitor对象(监视器),当获取到A对象的锁时,A对象的监视器对象中有个字段会指向当前线程,表示这个线程获取到A对象的锁(详细原理后文描述)

synchronized可以作用于普通对象和静态对象,当作用于静态对象、静态方法时,都是去获取其对应的Class对象的锁

synchronized作用在代码块上时,会使用monitorentry和monitorexit字节码指令来标识加锁、解锁

synchronized作用在方法上时,会在访问标识上加上synchronized

指令中可能出现两个monitorexit指令是因为当发生异常时,会自动执行monitorexit进行解锁

正常流程是PC 12-14,如果在此期间出现异常就会跳转到PC 17,最终在19执行monitorexit进行解锁

        Object obj = new Object();
        synchronized (obj) {

        }

15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized

在上篇文章中我们说过原子性、可见性以及有序性

synchronized加锁解锁的字节码指令使用屏障,加锁时共享内存从主内存中重新读取,解锁前把工作内存数据写回主内存以此来保证可见性

由于获取到锁才能执行相当于串行执行,也就保证原子性和有序性,需要注意的是加锁与解锁之间的指令还是可以重排序的

CAS

为了更好的说明synchronized原理和锁升级,我们先来聊聊CAS

在上篇文章中我们说过,volatile不能保证复合操作的原子性,使用synchronized方法或者CAS能够保证复合操作原子性

那什么是CAS呢?

CAS全称 Compare And Swap 比较并交换,读取数据后要修改时用读取的数据和地址上的值进行比较,如果相等那就将地址上的值替换为目标值,如果不相等,通常会重新读取数据再进行CAS操作,也就是失败重试

synchronized加锁是一种悲观策略,每次遇到时都认为会有并发问题,要先获取锁才操作

而CAS是一种乐观策略,每次先大胆的去操作,操作失败(CAS失败)再使用补偿措施(失败重试)

CAS与失败重试(循环)的组合构成乐观锁或者说自旋锁(循环尝试很像在自我旋转)

并发包下的原子类,依靠Unsafe大量使用CAS操作,比如AtomicInteger的自增

    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

    //var1是调用方法的对象,var2是需要读取/修改的值在这个对象上的偏移量,var4是自增1
    public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
            //var5是通过对象和字段偏移量获取到字段最新值
            var5 = this.getIntVolatile(var1, var2);
            //cas:var1,var2找到字段的值 与 var5比较,相等就替换为 var5+var4 
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
        return var5;
    }

CAS只能对一个变量进行操作,如果要对多个变量进行操作,那么只能对外封装一层(将多个变量封装为新对象的字段),再使用原子类中的AtomicReference

不知各位同学有没有发现,CAS的流程有个bug,就是在读数据与比较数据之间,如果数据从A被改变到B,再改变到A,那么CAS也能执行成功

这种场景有的业务能够接受,有的业务无法接受,这就是所谓的ABA问题

而解决ABA问题的方式比较简单,可以再比较时附加一个自增的版本号,JDK也提供解决ABA问题的原子类AtomicStampedReference

CAS能够避免线程阻塞,但如果一直失败就会一直循环,增加CPU的开销,CAS失败后重试的次数/时长不好评估

因此CAS操作适用于竞争小的场景,用CPU空转的开销来换取线程阻塞挂起/恢复的开销

锁升级

早期版本的synchronized会将获取不到锁的线程直接挂起,性能不好

JDK 6 时对synchronized的实现进行优化,也就是锁升级

锁的状态可以分为无锁、偏向锁、轻量级锁、重量级锁

可以暂时把重量级锁理解为早期获取不到锁就让线程挂起,新的优化也就是轻量级锁和偏向锁

mark word

为了更好的说明锁升级,我们先来聊聊Java对象头中的mark word

我们下面的探究都是围绕64位的虚拟机

Java对象的内存由mark word、klass word、如果是数组还要记录长度、实例数据(字段)、对其填充(填充到8字节倍数)组成

mark word会记录锁状态,在不同锁状态的情况下记录的数据也不同

下面这个表格是从无锁到重量级锁mark word记录的内容

|----------------------------------------------------------------------|--------|--------|
| unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1  | lock:2 | 无锁   
|----------------------------------------------------------------------|--------|--------|
|  thread:54 |         epoch:2      | unused:1 | age:4 | biased_lock:1 | lock:2 | 偏向锁
|----------------------------------------------------------------------|--------|--------|
|                     ptr_to_lock_record:62                            | lock:2 | 轻量级锁
|----------------------------------------------------------------------|--------|--------|
|                     ptr_to_heavyweight_monitor:62                    | lock:2 | 重量级锁
|----------------------------------------------------------------------|--------|--------|

unused 表示还没使用

identity_hashcode 用于记录一致性哈希

age 用于记录GC年龄

biased_lock 标识是否使用偏向锁,0表示未开启,1表示开启

lock 用于标识锁状态标志位,01无锁或偏向锁、00轻量级锁、10重量级锁

thread 用于标识偏向的线程

epoch 记录偏向的时间戳

ptr_to_lock_record 记录栈帧中的锁记录(后文介绍)

ptr_to_heavyweight_monitor 记录获取重量级锁的线程

jol查看mark word

比较熟悉mark word的同学可以跳过

了解mark word后再来熟悉下不同锁状态下的mark word,我使用的是jol查看内存

       <!-- https://mvnrepository.com/artifact/org.openjdk.jol/jol-core -->
        <dependency>
            <groupId>org.openjdk.jol</groupId>
            <artifactId>jol-core</artifactId>
            <version>0.12</version>
        </dependency>
无锁

各位同学实验时的mark word可能和我注释中的不同,我们主要查看锁标识的值和是否启用偏向锁

15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized

    public void noLock() {
        Object obj = new Object();
        //mark word  00000001 被unused:1,age:4,biased_lock:1,lock:2使用,001表示0未启用偏向锁,01表示无锁
        //01 00 00 00  (00000001 00000000 00000000 00000000)
        //00 00 00 00  (00000000 00000000 00000000 00000000)
        ClassLayout objClassLayout = ClassLayout.parseInstance(obj);
        System.out.println(objClassLayout.toPrintable());

        //计算一致性哈希后
        //01 b6 ce a8
        //6a 00 00 00
        obj.hashCode();
        System.out.println(objClassLayout.toPrintable());

        //进行GC 查看GC年龄 0 0001 0 01 前2位表示锁状态01无锁,第三位biased_lock为0表示未启用偏向锁,后续四位则是GC年龄age 1
        //09 b6 ce a8 (00001001 10110110 11001110 10101000)
        //6a 00 00 00 (01101010 00000000 00000000 00000000)
        System.gc();
        System.out.println(objClassLayout.toPrintable());
    }
轻量级锁
    public void lightLockTest() throws InterruptedException {
        Object obj = new Object();
        ClassLayout objClassLayout = ClassLayout.parseInstance(obj);
        //1334729950
        System.out.println(obj.hashCode());
        //0 01 无锁
        //01 4e c0 d5 (00000001 01001110 11000000 11010101)
        //6a 00 00 00 (01101010 00000000 00000000 00000000)
        System.out.println(Thread.currentThread().getName() + ":");
        System.out.println(objClassLayout.toPrintable());


        Thread thread1 = new Thread(() -> {
            synchronized (obj) {
                // 110110 00 中的00表示轻量级锁其他62位指向拥有锁的线程
                //d8 f1 5f 1d (11011000 11110001 01011111 00011101)
                //00 00 00 00 (00000000 00000000 00000000 00000000)
                System.out.println(Thread.currentThread().getName() + ":");
                System.out.println(objClassLayout.toPrintable());

                //1334729950
                //无锁升级成轻量级锁后 hashcode未变 对象头中没存储hashcode 只存储拥有锁的线程
                //(实际上mark word内容被存储到lock record中,所以hashcode也被存储到lock record中)
                System.out.println(obj.hashCode());
            }
        }, "t1");

        thread1.start();
        //等待t1执行完 避免 发生竞争
        thread1.join();

        //轻量级锁 释放后 mark word 恢复成无锁 存储哈希code的状态
        //01 4e c0 d5 (00000001 01001110 11000000 11010101)
        //6a 00 00 00 (01101010 00000000 00000000 00000000)
        System.out.println(Thread.currentThread().getName() + ":");
        System.out.println(objClassLayout.toPrintable());

        Thread thread2 = new Thread(() -> {
            synchronized (obj) {
                //001010 00 中的00表示轻量级锁其他62位指向拥有锁的线程
                //28 f6 5f 1d (00101000 11110110 01011111 00011101)
                //00 00 00 00 (00000000 00000000 00000000 00000000)
                System.out.println(Thread.currentThread().getName() + ":");
                System.out.println(objClassLayout.toPrintable());
            }
        }, "t2");
        thread2.start();
        thread2.join();
    }
偏向锁
    public void biasedLockTest() throws InterruptedException {
        //延迟让偏向锁启动
        Thread.sleep(5000);

        Object obj = new Object();
        ClassLayout objClassLayout = ClassLayout.parseInstance(obj);

        //1 01 匿名偏向锁 还未设置偏向线程
        //05 00 00 00 (00000101 00000000 00000000 00000000)
        //00 00 00 00 (00000000 00000000 00000000 00000000)
        System.out.println(Thread.currentThread().getName() + ":");
        System.out.println(objClassLayout.toPrintable());

        synchronized (obj) {
            //偏向锁 记录 线程地址
            //05 30 e3 02 (00000101 00110000 11100011 00000010)
            //00 00 00 00 (00000000 00000000 00000000 00000000)
            System.out.println(Thread.currentThread().getName() + ":");
            System.out.println(objClassLayout.toPrintable());
        }

        Thread thread1 = new Thread(() -> {
            synchronized (obj) {
                //膨胀为轻量级 0 00 0未启用偏向锁,00轻量级锁
                //68 f4 a8 1d (01101000 11110100 10101000 00011101)
                //00 00 00 00 (00000000 00000000 00000000 00000000)
                System.out.println(Thread.currentThread().getName() + ":");
                System.out.println(objClassLayout.toPrintable());
            }
        }, "t1");

        thread1.start();
        thread1.join();
    }
重量级锁
    public void heavyLockTest() throws InterruptedException {
        Object obj = new Object();
        ClassLayout objClassLayout = ClassLayout.parseInstance(obj);
        Thread thread1 = new Thread(() -> {
            synchronized (obj) {
                //第一次 00 表示 轻量级锁
                //d8 f1 c3 1e (11011000 11110001 11000011 00011110)
                //00 00 00 00 (00000000 00000000 00000000 00000000)
                System.out.println(Thread.currentThread().getName() + ":");
                System.out.println(objClassLayout.toPrintable());

                //用debug控制t2来竞争
                //第二次打印 变成 10 表示膨胀为重量级锁(t2竞争)  其他62位指向监视器对象
                //fa 21 3e 1a (11111010 00100001 00111110 00011010)
                //00 00 00 00 (00000000 00000000 00000000 00000000)
                System.out.println(Thread.currentThread().getName() + ":");
                System.out.println(objClassLayout.toPrintable());
            }
        }, "t1");

        thread1.start();

        Thread thread2 = new Thread(() -> {
            synchronized (obj) {
                //t2竞争 膨胀为 重量级锁 111110 10 10为重量级锁
                //fa 21 3e 1a (11111010 00100001 00111110 00011010)
                //00 00 00 00 (00000000 00000000 00000000 00000000)
                System.out.println(Thread.currentThread().getName() + ":");
                System.out.println(objClassLayout.toPrintable());
            }
        }, "t2");
        thread2.start();

        thread1.join();
        thread2.join();

        //10 重量级锁 未发生锁降级
        //3a 36 4d 1a (00111010 00110110 01001101 00011010)
        //00 00 00 00 (00000000 00000000 00000000 00000000)
        System.out.println(Thread.currentThread().getName() + ":");
        System.out.println(objClassLayout.toPrintable());
    }

轻量级锁

轻量级锁的提出是为了减小传统重量级锁使用互斥量(挂起/恢复线程)所产生的开销

面对较少的竞争场景时,获取锁的时间总是短暂的,而挂起线程用户态、内核态的开销比较大,使用轻量级锁减少开销

那么轻量级锁是如何实现的呢?

轻量级锁主要由lock record、mark word、CAS来实现,lock record存储在线程的栈帧中,来记录锁的信息

加锁

查看对象是不是无锁状态,如果对象是无锁状态,会将mark word复制到lock record锁记录中的displaced mark word

15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized

然后再尝试使用CAS尝试将mark word中部分内容替换指向这个lock record,如果成功表示获取锁成功

15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized

如果对象持有锁,会查看持有锁的线程是不是当前线程,这种可重入的情况下lock record中记录不再是mark word而是null

可重入的情况下,只需要进行自增计数即可,解锁时遇到null的lock record则扣减

15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized

如果CAS失败或者持有锁的线程不是当前线程,就会触发锁膨胀

关键代码如下:

void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) {
  //当前对象的mark word
  markOop mark = obj->mark();
  assert(!mark->has_bias_pattern(), "should not see bias pattern here");

  //如果当前对象是无锁状态 
  if (mark->is_neutral()) {
    //将mark word复制到lock record
    lock->set_displaced_header(mark);
    //CAS将当前对象的mark word内容替换为指向lock record
    if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
      TEVENT (slow_enter: release stacklock) ;
      return ;
    }
  } else
  //如果有锁  判断是不是当前线程获取锁
  if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
    assert(lock != mark->locker(), "must not re-lock the same lock");
    assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock");
    //可重入锁 复制null
    lock->set_displaced_header(NULL);
    return;
  }

  //有锁并且获取锁的线程不是当前线程 或者 CAS失败 进行膨胀
  lock->set_displaced_header(markOopDesc::unused_mark());
  ObjectSynchronizer::inflate(THREAD, obj())->enter(THREAD);
}
解锁

查看lock record中复制的内容是不是空,是空说明是可重入锁

不为空则查看mark word是否指向lock record,如果指向则CAS尝试将mark word记录指向lock record替换为lock record中的displaced mark word(也就是原来的mark word)

如果mark word不指向lock record 或者 CAS失败了 说明存在竞争,其他线程加锁失败让mark word指向重量级锁,直接膨胀

15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized

关键代码如下:

void ObjectSynchronizer::fast_exit(oop object, BasicLock* lock, TRAPS) {
  assert(!object->mark()->has_bias_pattern(), "should not see bias pattern here");

  //获取复制的mark word
  markOop dhw = lock->displaced_header();
  markOop mark ;
  //如果为空 说明是可重入
  if (dhw == NULL) {
     // Recursive stack-lock.
     // Diagnostics -- Could be: stack-locked, inflating, inflated.
     mark = object->mark() ;
     assert (!mark->is_neutral(), "invariant") ;
     if (mark->has_locker() && mark != markOopDesc::INFLATING()) {
        assert(THREAD->is_lock_owned((address)mark->locker()), "invariant") ;
     }
     if (mark->has_monitor()) {
        ObjectMonitor * m = mark->monitor() ;
        assert(((oop)(m->object()))->mark() == mark, "invariant") ;
        assert(m->is_entered(THREAD), "invariant") ;
     }
     return ;
  }

  mark = object->mark() ;

  //如果mark word指向lock record
  if (mark == (markOop) lock) {
     assert (dhw->is_neutral(), "invariant") ;
     //尝试CAS将指向lock record的mark word替换为原来的内容
     if ((markOop) Atomic::cmpxchg_ptr (dhw, object->mark_addr(), mark) == mark) {
        TEVENT (fast_exit: release stacklock) ;
        return;
     }
  }

  //未指向当前lock record或者CAS失败则膨胀
  ObjectSynchronizer::inflate(THREAD, object)->exit (true, THREAD) ;
}

偏向锁

hotspot开发人员测试,在某些场景下,总是同一个线程获取锁,在这种场景下,希望用更小的开销来获取锁

当开启偏向锁后,如果是无锁状态会将mark word改为偏向某个线程ID,以此标识这个线程获取锁(锁偏向这个线程)

如果正处于偏向锁,遇到竞争可能膨胀为轻量级锁,如果要存储一致性哈希等情况也会膨胀为重量级锁

JDK8默认开启偏向锁,在高版本JDK默认不开启偏向锁,可能因为偏向锁的维护超过收益,我们也不深入进行研究

重量级锁

object monitor

使用object monitor对象来实现重量级锁

object monitor中使用一些字段记录信息,比如:object字段用于记录锁的那个对象,header字段用于记录锁的那个对象的mark word、owner字段用于记录持有锁的线程

object monitor使用阻塞队列来存储竞争不到锁的线程,使用等待队列来存储调用wait进入等待状态的线程

阻塞队列和等待队列类比着并发包下的AQS和Condition

object monitor使用cxq栈和entry list队列来实现阻塞队列,其中cxq栈中存储有竞争的线程,entry list存储已经竞争失败较稳定的线程;使用wait set实现等待队列

当线程调用wait时,进入wait set等待队列

而调用notify时,只是将等待队列的队头节点加入cxq,并没有唤醒该线程去竞争

真正的唤醒线程是在释放锁时,去稳定的队列entry list中唤醒队头节点去竞争,而此时被唤醒的节点并不一定能抢到锁,因为线程进入cxq时还会通过自旋来抢锁,以此来实现非公平锁

如果稳定的entry list中没有存储线程,会将cxq栈中存储的线程全存储到entry list中再去唤醒,此时越晚进入cxq的线程反而会越早被唤醒(cxq栈先进后出)

其实实现与AQS类似,来看这样一段代码:

t1-t6获取同一把锁,使用t1线程进行阻塞一会,后续t2-t6线程按照顺序启动,由于自转获取不到锁,它们会被依次放入cxq:t2,t3,t4,t5,t6

在t1释放锁时,由于entry list中没有线程,于是将cxq中的线程存入entry list:t6,t5,t4,t3,t2,再唤醒t6

由于后续没有线程进行竞争,因此最终执行顺序为t1,t6,t5,t4,t3,t2

Object obj = new Object();
new Thread(() -> {
    synchronized (obj) {
        try {
            //输入阻塞
            //阻塞的目的是让  其他线程自旋完未获取到锁,进入cxq栈
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 获取到锁");
    }
}, "t1").start();

//sleep控制线程阻塞的顺序
Thread.sleep(50);
new Thread(() -> {
    synchronized (obj) {
        System.out.println(Thread.currentThread().getName() + " 获取到锁");
    }
}, "t2").start();

Thread.sleep(50);
new Thread(() -> {
    synchronized (obj) {
        System.out.println(Thread.currentThread().getName() + " 获取到锁");
    }
}, "t3").start();

Thread.sleep(50);
new Thread(() -> {
    synchronized (obj) {
        System.out.println(Thread.currentThread().getName() + " 获取到锁");
    }
}, "t4").start();

Thread.sleep(50);
new Thread(() -> {
    synchronized (obj) {
        System.out.println(Thread.currentThread().getName() + " 获取到锁");
    }
}, "t5").start();

Thread.sleep(50);
new Thread(() -> {
    synchronized (obj) {
        System.out.println(Thread.currentThread().getName() + " 获取到锁");
    }
}, "t6").start();

大致了解了下object monitor,我们再来看看膨胀和自旋

膨胀

在膨胀时会有四种状态,分别是

inflated 已膨胀:mark word锁标志为10(2)说明已膨胀,直接返回object monitor

inflation in progress 膨胀中:如果已经有其他线程在膨胀了,就等待一会循环后查看状态进入已膨胀的逻辑

stack-locked 轻量级锁膨胀

neutral 无锁膨胀

轻量级锁和无锁膨胀逻辑差不多,都是需要创建object monitor对象,并且set一些属性进去(比如:mark word、锁的哪个对象、哪个线程持有锁...),最后再使用CAS去替换mark word指向object monitor

ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {

  for (;;) {
      const markOop mark = object->mark() ;
      assert (!mark->has_bias_pattern(), "invariant") ;

      // The mark can be in one of the following states:
      // *  Inflated     - just return
      // *  Stack-locked - coerce it to inflated
      // *  INFLATING    - busy wait for conversion to complete
      // *  Neutral      - aggressively inflate the object.
      // *  BIASED       - Illegal.  We should never see this

      // CASE: inflated 
      // 已膨胀:查看 mark word 后两位是否为2  是则膨胀完 返回monitor对象
      if (mark->has_monitor()) {
          ObjectMonitor * inf = mark->monitor() ;
          assert (inf->header()->is_neutral(), "invariant");
          assert (inf->object() == object, "invariant") ;
          assert (ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is invalid");
          return inf ;
      }

      // CASE: inflation in progress - inflating over a stack-lock.
      // 膨胀中: 等待一会 再循环 从膨胀完状态退出
      if (mark == markOopDesc::INFLATING()) {
         TEVENT (Inflate: spin while INFLATING) ;
         ReadStableMark(object) ;
         continue ;
      }

      // CASE: stack-locked
      //轻量级锁膨胀
      if (mark->has_locker()) {
          //创建ObjectMonitor
          ObjectMonitor * m = omAlloc (Self) ;
          m->Recycle();
          m->_Responsible  = NULL ;
          m->OwnerIsThread = 0 ;
          m->_recursions   = 0 ;
          m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;   // Consider: maintain by type/class
          //cas将mark word替换指向ObjectMonitor
          markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;         
          //cas 失败 则说明其他线程膨胀成功,删除当前monitor 退出
          if (cmp != mark) {
             omRelease (Self, m, true) ;
             continue ;       // Interference -- just retry
          }
          markOop dmw = mark->displaced_mark_helper() ;
          assert (dmw->is_neutral(), "invariant") ;

          //成功 设置mark word
          m->set_header(dmw) ;
          //设置持有锁的线程
          m->set_owner(mark->locker());
          //设置锁的是哪个对象
          m->set_object(object);
          guarantee (object->mark() == markOopDesc::INFLATING(), "invariant") ;
          //修改mark word对象头信息 锁状态 2
          object->release_set_mark(markOopDesc::encode(m));
          if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ;
          TEVENT(Inflate: overwrite stacklock) ;
          if (TraceMonitorInflation) {
            if (object->is_instance()) {
              ResourceMark rm;
              tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
                (void *) object, (intptr_t) object->mark(),
                object->klass()->external_name());
            }
          }
          return m ;
      }

      // CASE: neutral
      //无锁膨胀 与轻量级锁膨胀类似,也是创建monitor对象并注入属性,只是很多属性为空
      assert (mark->is_neutral(), "invariant");

      ObjectMonitor * m = omAlloc (Self) ;
      m->Recycle();
      m->set_header(mark);
      m->set_owner(NULL);
      m->set_object(object);
      m->OwnerIsThread = 1 ;
      m->_recursions   = 0 ;
      m->_Responsible  = NULL ;
      m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;       // consider: keep metastats by type/class
      //cas 更新 mark word 失败循环等待  成功返回
      if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
          m->set_object (NULL) ;
          m->set_owner  (NULL) ;
          m->OwnerIsThread = 0 ;
          m->Recycle() ;
          omRelease (Self, m, true) ;
          m = NULL ;
          continue ;
      }
     
      if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ;
      TEVENT(Inflate: overwrite neutral) ;
      if (TraceMonitorInflation) {
        if (object->is_instance()) {
          ResourceMark rm;
          tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
            (void *) object, (intptr_t) object->mark(),
            object->klass()->external_name());
        }
      }
      return m ;
  }
}
自旋

膨胀过后,在最终挂起前会进行固定自旋和自适应自旋

固定自旋默认10+1次

自适应自旋一开始5000次,如果最近竞争少获取到锁就将自旋次数调大,如果最近竞争大获取不到锁就将自旋次数调小

int ObjectMonitor::TrySpin_VaryDuration (Thread * Self) {

    // Dumb, brutal spin.  Good for comparative measurements against adaptive spinning.
    int ctr = Knob_FixedSpin ;
    if (ctr != 0) {
        while (--ctr >= 0) {
            if (TryLock (Self) > 0) return 1 ;
            SpinPause () ;
        }
        return 0 ;
    }
    //先进行固定11自旋次数 获取到锁返回,没获取到空转
    for (ctr = Knob_PreSpin + 1; --ctr >= 0 ; ) {
      if (TryLock(Self) > 0) {
        // Increase _SpinDuration ...
        // Note that we don't clamp SpinDuration precisely at SpinLimit.
        // Raising _SpurDuration to the poverty line is key.
        int x = _SpinDuration ;
        if (x < Knob_SpinLimit) {
           if (x < Knob_Poverty) x = Knob_Poverty ;
           _SpinDuration = x + Knob_BonusB ;
        }
        return 1 ;
      }
      SpinPause () ;
    }
    
    //自适应自旋 一开始5000 如果成功认为此时竞争不大 自旋获取锁成功率高 增加重试次数 如果失败则减少
    //...
}   

总结

本篇文章围绕synchronized,深入浅出的描述CAS、synchronized在Java层面和C++层面的实现、锁升级原理、案例、源码等

synchronized用于并发下的需要同步的场景,使用它可以满足原子性、可见性以及有序性,它可以作用在普通对象和静态对象,作用于静态对象时是去获取其对应的Class对象的锁

synchronized作用在代码块上时,使用monitorentry、monitorexit字节码指令来标识加锁、解锁;作用在方法上时,在访问标识加锁synchronized关键字,虚拟机隐式使用monitorentry、monitorexit

CAS 比较并替换,常与重试机制实现乐观锁/自旋锁,优点是能够在竞争小的场景用较小的开销取代线程挂起,但带来ABA问题、无法预估重试次数空转CPU的开销等问题

轻量级锁的提出是为了在交替执行/竞争少的场景,用更小的开销取代互斥量;使用CAS和lock record实现

轻量级锁加锁时,如果是无锁则复制mark word到lock record中,再CAS将对象mark word替换为指向该lock record,失败则膨胀;如果已经持有锁则判断持有锁的线程是不是当前线程,是则累加次数,不是当前线程则膨胀

轻量级锁解锁时,查看lock record复制的是不是null,是则说明是可重入锁,次数减一;不是则CAS把复制过来的mark word替换回去,如果替换失败说明其他线程竞争,mark word已经指向object monitor,去指向重量级锁的释放

偏向锁的提出是为了在经常一条线程执行的场景下,用更小的开销来取代CAS的开销,只不过高版本不再默认开启

重量级锁由object monitor来实现,object monitor中使用cxq、entry list来构成阻塞队列,wait set来构成等待队列

当执行wait方法时,线程构建为节点加入wait set;当执行notify方法时,将wait set队头节点加入cxq,在释放锁时才去唤醒entry list队头节点竞争锁,即使没抢到锁构建为节点加入cxq时还会自旋,因此并不是entry list队头节点就一定能抢到锁,以此来实现非公平锁;当entry list为空时,将cxq栈中的节点加入entry list队列(后进入cxq的节点会被先唤醒)

在膨胀为重量级锁时有四种情况,如果状态为已膨胀则直接返回object monitor对象;如果状态为膨胀中,说明其他线程正在膨胀,等待会,下次循环进入已膨胀的逻辑;如果状态为轻量级锁膨胀或无锁膨胀,都会去创建object monitor对象,set一些重要属性,并CAS去将mark word替换为指向该object monitor

重量级锁在最终挂起前会进行固定自旋和自适应自旋(最近竞争小就增加自旋次数;竞争多就减少自旋次数)

最后(不要白嫖,一键三连求求拉~)

本篇文章被收入专栏 由点到线,由线到面,深入浅出构建Java并发编程知识体系,感兴趣的同学可以持续关注喔

本篇文章笔记以及案例被收入 gitee-StudyJava、 github-StudyJava 感兴趣的同学可以stat下持续关注喔~

案例地址:

Gitee-JavaConcurrentProgramming/src/main/java/B_synchronized

Github-JavaConcurrentProgramming/src/main/java/B_synchronized

有什么问题可以在评论区交流,如果觉得菜菜写的不错,可以点赞、关注、收藏支持一下~

关注菜菜,分享更多干货,公众号:菜菜的后端私房菜

本文由博客一文多发平台 OpenWrite 发布!文章来源地址https://www.toymoban.com/news/detail-696094.html

到了这里,关于15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 一文让你彻底搞懂AQS(通俗易懂的AQS)

    AQS是一个用来构建锁和同步器的框架,使用AQS能简单且高效地构造出应用广泛的大量的同步器,比如我们提到的ReentrantLock,Semaphore,其他的诸如ReentrantReadWriteLock,SynchronousQueue,FutureTask等等皆是基于AQS的。当然,我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的

    2024年02月17日
    浏览(37)
  • 一本书让你彻底搞懂安卓系统性能优化(文末送书5本)

    🤵‍♂️ 个人主页:@艾派森的个人主页 ✍🏻作者简介:Python学习者 🐋 希望大家多多支持,我们一起进步!😄 如果文章对你有帮助的话, 欢迎评论 💬点赞👍🏻 收藏 📂加关注+ 目录 前言 作者简介 内容简介  本书特色 读者对象 直播预告 文末福利         为什么

    2024年02月08日
    浏览(48)
  • 彻底搞懂贝塞尔曲线的原理

    贝塞尔曲线介绍 我们在前面讲了绘制自定义曲线,而实际开发过程还会遇到更复杂的图形绘制,比如下面的这些图形: 这时候就需要用到贝塞尔曲线了。下面是百科关于贝塞尔曲线的介绍。 贝塞尔曲线就是这样的一条曲线,它是依据四个位置任意的点坐标绘制出的一条光滑

    2024年02月20日
    浏览(42)
  • 一张图让你理解 IaaS、SaaS 和 PaaS 的区别?

    大家看下面这张图,我将从概念,服务,公司和发展,4 个方面,给大家通俗的解释下,什么是:SaaS,PaaS 和 IaaS:  SaaS,Paas,IaaS 的区别 互联网发展到今天,人类已经无法离开互联网而存在,我们日常会用到的微信,抖音,淘宝等,都是面向个人用户的,打开就可以立即使

    2023年04月21日
    浏览(47)
  • 一文彻底搞懂 TCP三次握手、四次挥手过程及原理

    TCP 协议简述 TCP 提供面向有连接的通信传输,面向有连接是指在传送数据之前必须先建立连接,数据传送完成后要释放连接。 无论哪一方向另一方发送数据之前,都必须先在双方之间建立一条连接。在TCP/IP协议中,TCP协议提供可靠的连接服务,连接是通过 三次握手 进行初始

    2024年02月04日
    浏览(36)
  • 一文彻底搞懂TCP/IP、UDP、FTP、HTTP、HTTPS的基本原理

    基本原理:TCP/IP是一组用于实现网络通信的协议族,它是互联网的基础协议。TCP/IP协议族由两个主要协议组成:TCP(Transmission Control Protocol,传输控制协议)和IP(Internet Protocol,网际协议)。 TCP(Transmission Control Protocol):TCP是一种面向连接的、可靠的、基于字节流的传输层

    2024年03月08日
    浏览(36)
  • 一篇文章让你彻底了解vuex的使用及原理(上)

    文章讲解的 Vuex 的版本为 4.1.0 ,会根据一些 api 来深入源码讲解,帮助大家更快掌握 vuex 的使用。 使用 Vue 实例的 use 方法把 Vuex 实例注入到 Vue 实例中。 use 方法执行的是插件的中的 install 方法 src/store.js 从上面可以看到 Vue 实例通过 provide 方法把 store 实例 provide 到了根实例

    2023年04月23日
    浏览(59)
  • 【Spring框架】一篇文章带你彻底搞懂Spring解决循环依赖的底层原理

    目录 一、前言 二、什么是循环依赖 三、Spring Bean 的循环依赖问题 3.1 Bean 的创建步骤 3.2 为什么 Spring Bean 会产生循环依赖问题? 3.3 什么情况下循环依赖可以被处理? 四、Spring 如何解决循环依赖问题? 4.0 什么是三级缓存 4.1 简单的循环依赖(没有AOP) 4.1.0 创建Bean的前期流

    2024年04月17日
    浏览(57)
  • [Data structure]队列&环形队列 | 一文带你彻底搞懂队列和环形队列(内附详细图解和代码实现)

    ⭐作者介绍:大二本科网络工程专业在读,持续学习Java,努力输出优质文章 ⭐作者主页:@逐梦苍穹 ⭐所属专栏:数据结构。数据结构专栏主要是在讲解原理的基础上拿Java实现 ⭐如果觉得文章写的不错,欢迎点个关注一键三连😉有写的不好的地方也欢迎指正,一同进步😁

    2023年04月17日
    浏览(95)
  • 前端开发攻略---从源码角度分析Vue3的Propy比Vue2的defineproperty到底好在哪里。一篇文章让你彻底弄懂响应式原理。

    Vue的响应式到底要干什么? 无非就是要知道当你 读取 对象的时候,要知道它读了。要做一些别的事情 无非就是要知道当你 修改 对象的时候,要知道它改了。要做一些别的事情 所以要想一个办法, 把读取和修改的动作变成一个函数 ,读取和修改的时候分别调用对应的函数

    2024年04月17日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包