白话 Synchronized

简介

synchronize 关键字用起来非常简单,但JDK1.6的底层实现却很复杂。
JDK1.6开始JVM对synchronize底层做了优化。
上一篇
https://www.jianshu.com/p/aeb0a68709cb

源代码及部分注释:
https://github.com/sparrowzoo/open-jdk8/blob/master/hotspot/src/share/vm/oops/markOop.hpp

Bit-format of an object header

 Bit-format of an object header (most significant first, big endian layout below):
//
//  32 bits:
//  --------
//             hash:25 ------------>| age:4    biased_lock:1 lock:2 (normal object)//MaxTenuringThreshold (GC次数)最大为15
//             JavaThread*:23 epoch:2 age:4    biased_lock:1 lock:2 (biased object)//偏向
//             size:32 ------------------------------------------>| (CMS free block)
//             PromotedObject*:29 ---------->| promo_bits:3 ----->| (CMS promoted object) //晋升对象
//
//  64 bits:
//  --------
//  unused:25 hash:31 -->| unused:1   age:4    biased_lock:1 lock:2 (normal object)
//  JavaThread*:54 epoch:2 unused:1   age:4    biased_lock:1 lock:2 (biased object)
//  PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object)
//  size:64 ----------------------------------------------------->| (CMS free block)
//
//  64 bits COOPS:
//  --------
//  unused:25 hash:31 -->| cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && normal object)
//  JavaThread*:54 epoch:2 cms_free:1 age:4    biased_lock:1 lock:2 (COOPs && biased object)
//  narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object)
//  unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block)
//
  • hash (25/31)
    hash contains the identity hash value: largest value is
    31 bits, see os::random().  Also, 64-bit vm's require
    a hash value no bigger than 32 bits because they will not
    properly generate a mask larger than that: see library_call.cpp
    and c1_CodePatterns_sparc.cpp.

hash 是唯一的hash value,最大位是31bits,参见os::random().64位虚拟机也不可能生成大于32位的hash value.
hash_bits = max_hash_bits > 31 ? 31 : max_hash_bits

// Constants
  enum { age_bits                 = 4,
         lock_bits                = 2,
         biased_lock_bits         = 1,
         max_hash_bits            = BitsPerWord - age_bits - lock_bits - biased_lock_bits,
         hash_bits                = max_hash_bits > 31 ? 31 : max_hash_bits,(hash位数)
         cms_bits                 = LP64_ONLY(1) NOT_LP64(0),
         epoch_bits               = 2
  };
  • age(4)

4位,因此MaxTenuringThreshold (GC次数)最大为15

  • biased_lock(1)

1位,因为锁标记的两位(01)代码无锁和偏向锁,所以加一位来区分

  • lock(2)
    2 位,具体见下表
  • JavaThread指针
The runtime system aligns all JavaThread* pointers to
    a very large value (currently 128 bytes (32bVM) (7) or 256 (8) bytes (64bVM))
   to make room for the age bits & the epoch bits (used in support of
    biased locking), and for the CMS "freeness" bit in the 64bVM (+COOPs)

运行时会将JavaThread*以一个非常大的值对齐(128 bytes (32b vm) or 256 (64v VM),为了age bits epoch bits 以及压缩指针的CMS freeness 位腾出空间。

  • epoch(2)
    该字段为两位,在锁在起到的作用参见
    https://www.zhihu.com/question/56582060/answer/155398235
    简单解析:
    对象每次初始化时(或者说被加偏向锁时)会从类的头信息中获取该值,每加一次偏向锁类的头信息的值+1,同时对象的值也加+1,当类的值超过4(2bits)时,那么该类将不适合偏向锁。
markOop incr_bias_epoch() {
    return set_bias_epoch((1 + bias_epoch()) & epoch_mask);
  }
  • 轻量锁和重量锁指针
    We assume that stack/thread pointers have the lowest two bits cleared.
    让出锁标志两位,所以该指为wordsize-2,因为 java 对象8字节对齐(3位),让出两位没有问题。

  • CMS
    其他字段为 cms gc相关。

4个锁级别

  1. 无锁
 [header  |0 | 01]  unlocked           regular object header
[hashCode|age|0|01
  1. 偏向锁
    the biased lock pattern is used to bias a lock toward a given thread. When this pattern is set in the low three bits, the lock is either biased toward a given thread or "anonymously" biased, indicating that it is possible for it to be biased. When the lock is biased toward a given thread, locking and unlocking can be performed by that thread without using atomic operations. When a lock's bias is revoked, it reverts back to the normal locking scheme described below.

the biased lock pattern 通常用于偏向指定的线程。当这个模式的低三位被set时,那么这个编向锁可以指向指定的线程或 "anonymously" biased,来标志这个对象可能被偏向锁了,当这个锁被偏向提定的线程时,加锁和解锁都不需要原子操作,当锁的偏向解除时,它恢复回原来的schema。
注:Synchronized 会保证可见性

 [JavaThread* | epoch | age | 1 | 01]       lock is biased toward given thread
 [0           | epoch | age | 1 | 01]       lock is anonymously biased
  1. 轻量级锁
[ptr             | 00]  locked             ptr points to real header on stack

这时的指针指向stack 的对象头

参考
https://pdfs.semanticscholar.org/bc8f/7a35b87b452924e180ed15b58f049bcac9db.pdf

白话 Synchronized_第1张图片
light-lock-1.jpg
白话 Synchronized_第2张图片
light-lock-2.jpg
  • 加锁
    1. 为线程分配lock record
    2. copy object mark wordlock record
    3. 通过CAS,尝试将object mark word的指针指向lock record,并将lock record owner的指针指向object mark word
  • 解锁
    简单理解就是加锁的相反操作,将object mark word的值从lock record 中还原。
Fast unlock atomically CASs displaced mark word
back into object header
> If success, no contention occurred
> If failed, monitor was inflated into heavyweight case
using OS-level locking primitives
> Enter run-time system, notify waiting threads`
  1. 重量级锁
 [ptr             | 10]  monitor            inflated lock (header is wapped out)

指针指向monitor对象
在Java虚拟机(HotSpot)中,monitor是由ObjectMonitor实现的,其主要数据结构如下(位于HotSpot虚拟机源码ObjectMonitor.hpp文件,C++实现的)

 // initialize the monitor, exception the semaphore, all other fields
  // are simple integers or pointers
  ObjectMonitor() {
    _header       = NULL;  //displaced object header word - mark
    _count        = 0;
    _waiters      = 0,     // number of waiting threads
    _recursions   = 0;
    _object       = NULL;  //backward object pointer - strong root
    _owner        = NULL;  //pointer to owning thread OR BasicLock
    _WaitSet      = NULL;  //LL of threads wait()ing on the monitor
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ; // number of waiting threads
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
    _previous_owner_tid = 0;
  }
白话 Synchronized_第3张图片
synchronous-lock.gif

由此可知

  1. 为什么Object.wait 和notify方法需要和Synchronized关键字配合使用。因为Object.wait将线程阻塞至Wait Set 对象,前提是已经拿到锁。
  2. Synchronized是一个非公平锁。

GC标志(不算锁级别)

[ptr             | 11]  marked             used by markSweep to mark an object
                                               not valid at any other time

CMS GC相关内容待整理

参考资料
http://ifeve.com/java-synchronized/

https://pdfs.semanticscholar.org/bc8f/7a35b87b452924e180ed15b58f049bcac9db.pdf

https://monkeysayhi.github.io/2018/01/02/%E6%B5%85%E8%B0%88%E5%81%8F%E5%90%91%E9%94%81%E3%80%81%E8%BD%BB%E9%87%8F%E7%BA%A7%E9%94%81%E3%80%81%E9%87%8D%E9%87%8F%E7%BA%A7%E9%94%81/

https://www.jianshu.com/p/fd780ef7a2e8

作者:
allanYan
https://www.jianshu.com/p/ec28e3a59e80

占小狼
https://www.jianshu.com/p/f4454164c017

你可能感兴趣的:(白话 Synchronized)