Java源码-synchronized

1 MarkWord

直接引用openjdk的cpp源码注释

// The markOop describes the header of an object.
//
// Note that the mark is not a real oop but just a word.
// It is placed in the oop hierarchy for historical reasons.
//
// 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)
//             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)
//
//  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 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.
//
//  - 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.
//
//    Note that we are overloading the meaning of the "unlocked" state
//    of the header. Because we steal a bit from the age we can
//    guarantee that the bias pattern will never be seen for a truly
//    unlocked object.
//
//    Note also that the biased state contains the age bits normally
//    contained in the object header. Large increases in scavenge
//    times were seen when these bits were absent and an arbitrary age
//    assigned to all biased objects, because they tended to consume a
//    significant fraction of the eden semispaces and were not
//    promoted promptly, causing an increase in the amount of copying
//    performed. The runtime system aligns all JavaThread* pointers to
//    a very large value (currently 128 bytes (32bVM) or 256 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* | epoch | age | 1 | 01]       lock is biased toward given thread
//    [0           | epoch | age | 1 | 01]       lock is anonymously biased
//
//  - the two lock bits are used to describe three states: locked/unlocked and monitor.
//
//    [ptr             | 00]  locked             ptr points to real header on stack
//    [header      | 0 | 01]  unlocked           regular object header
//    [ptr             | 10]  monitor            inflated lock (header is wapped out)
//    [ptr             | 11]  marked             used by markSweep to mark an object
//                                               not valid at any other time
//
//    We assume that stack/thread pointers have the lowest two bits cleared.

低3位组合标识5种状态

enum { locked_value             = 0, // ...000 // 轻量级锁
         unlocked_value           = 1, // ...001 // 无锁
         monitor_value            = 2, // ...010 重量级锁
         marked_value             = 3, // ...011 GC标识
         biased_lock_pattern      = 5 // ...101 偏向锁
  };

2 Java调试代码

package debug.object.jol;

import debug.object.jol.bean.Bean;
import org.junit.jupiter.api.Test;
import org.openjdk.jol.info.ClassLayout;

/**
 * <p>java中一个对象包含3个部分<ul>
 *     <li>对象头 12byte<ul>
 *         <li>MarkWord 8byte</li>
 *         <li>KlassWord 4byte 压缩指针后的大小</li>
 *     </ul></li>
 *     <li>实例数据</li>
 *     <li>对齐填充</li>
 * </ul></p>
 * @since 2022/5/27
 * @author dingrui
 */
public class JOLTest {

    public static void main(String[] args) throws InterruptedException {
        for (; ; ) {
        }
    }

    /**
     * <p>VM参数-XX:-UseCompressedOops 关闭指针压缩</p>
     * <pre>
     *     +--------+------+------------------------+---------------------------------------+
     *     | OFFSET | SIZE |          DES           |                VALUE                  |
     *     +--------+------+------------------------+---------------------------------------+
     *     |    0   |   8  | (object header: mark)  | 0x0000000000000005 (biasable; age: 0) |
     *     +--------+------+------------------------+---------------------------------------+
     *     |    8   |   8  | (object header: class) |          0x000000010e1e5d98           |
     *     +--------+------+------------------------+---------------------------------------+
     * </pre>
     * <p>Instance size: 16 bytes</p>
     * <p>Space losses: 0 bytes internal + 0 bytes external = 0 bytes total</p>
     */
    @Test
    public void testLayout00() {
        Bean b = new Bean();
        System.out.println(ClassLayout.parseInstance(b).toPrintable());
    }

    /**
     * <p>VM参数-XX:+UseCompressedOops 或者使用默认参数 打开指针压缩</p>
     * <pre>
     *     +--------+------+------------------------+---------------------------------------+
     *     | OFFSET | SIZE |          DES           |                VALUE                  |
     *     +--------+------+------------------------+---------------------------------------+
     *     |    0   |   8  | (object header: mark)  | 0x0000000000000005 (biasable; age: 0) |
     *     +--------+------+------------------------+---------------------------------------+
     *     |    8   |   4  | (object header: class) |              0x0016a9f0               |
     *     +--------+------+------------------------+---------------------------------------+
     *     |   12   |   4  | (object alignment gap) |                                       |
     *     +--------+------+------------------------+---------------------------------------+
     * </pre>
     * <p>Instance size: 16 bytes</p>
     * <p>Space losses: 0 bytes internal + 4 bytes external = 4 bytes total</p>
     * <p>指针压缩 字面意思 压缩了一个指针的大小<ul>
     *     <li>32位处理器每次能处理32bit=4byte的单位->指针保存的就是4字节的一条内存地址</li>
     *     <li>64位处理器每次能处理64bit=8byte的单位->指针保存的就是8字节的一条内存地址</li>
     * </ul> 一片内存都是从低位到高位 如果总是用8byte来标识一个指针位置也就意味着在一定阈值之内64位的高位会浪费掉 完全可以用低位表示这个指针</p>
     * <p>对齐填充 总和为8bytes的倍数</p>
     */
    @Test
    public void testLayout01() {
        Bean b = new Bean();
        System.out.println(ClassLayout.parseInstance(b).toPrintable());
    }

    /**
     * <p>jdk11的JVM默认启动参数没有使用偏向延迟技术</p>
     * <p>查看jvm的参数 jinfo -flags {pid}</p>
     * <p>通过启动VM添加参数 -XX:BiasedLockingStartupDelay=4000 启动偏向锁延迟 4秒钟</p>
     * <p>延迟偏向之前创建的对象 对象头MarkWord的值0x0000000000000001 即16进制的0000000000000001 对应的二进制为1 标识的状态是无锁状态</p>
     * <p>延迟偏向之后创建的对象 对象头MarkWord的值0x0000000000000005 即16进制的0000000000000005 对应的二进制为101 标识的状态是未偏向的偏向锁</p>
     */
    @Test
    public void testLayout02() throws InterruptedException {
        Bean b = new Bean();
        System.out.println(ClassLayout.parseInstance(b).toPrintable());

        Thread.sleep(4_000);
        b = new Bean();
        System.out.println(ClassLayout.parseInstance(b).toPrintable());
    }

    /**
     * <p>偏向延迟之前创建的无锁对象 经过synchronized之后直接变成轻量级锁</p>
     */
    @Test
    public void testLayout03() throws InterruptedException {
        Object o = new Object();
        /**
         * <p>0x0000000000000001->1->无锁</p>
         */
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        synchronized (o) {
            /**
             * <p>0x000070000a7a2fc8->11100000000000000001010011110100010111111001000->轻量级锁</p>
             */
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }

    /**
     * <p>没有开启偏向延迟或者偏向延迟之后创建的对象 状态是没有偏向的偏向锁 经过synchronized之后就变成偏向当前线程的偏向锁</p>
     */
    @Test
    public void testLayout04() {
        Object o = new Object();
        /**
         * <p>0x0000000000000005->101->没有偏向线程的偏向锁</p>
         */
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        synchronized (o) {
            /**
             * <p>0x00007f8f0a80e805->11111111000111100001010100000001110100000000101->有偏向线程的偏向锁</p>
             */
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }

    /**
     * <p>当对象处于偏向锁状态时mark word总共64bits 除去低2位锁标识 1位偏向标识就剩61位 这61位中还得留高54位用于记录线程id 那就还剩7位(2位epoch 1位不用 1位gc年龄)</p>
     * <p>显然 在偏向锁状态下 是没有地方存储对象的hashcode的 也就是说hashcode值跟偏向锁状态互斥<ul>
     *     <li>第一种情况 当前线程持有对象的锁 锁状态为偏向锁 在synchronized代码块内调用hashcode之后 锁升级为轻量级锁</li>
     *     <li>第二种情况 当前对象无锁 调用hashcode之后 synchronized获取到的是轻量级锁 跳过偏向锁</li>
     * </ul></p>
     */
    @Test
    public void testLayout05() {
        Object o = new Object();
        // 0x0000000000000005->101->无偏向的偏向锁
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        synchronized (o) {
            // 0x00007ffac1019805->11111111111101011000001000000011001100000000101->偏向当前线程的偏向锁
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
            o.hashCode();
            // 0x00007ffabff13702->11111111111101010111111111100010011011100000010
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }

    /**
     * <p>完整的锁升级过程 锁的膨胀升级肯定跟竞争有关系 但是升级之后的锁状态还跟是否进行了一次hashcode方法求值有关系</p>
     */
    @Test
    public void testLayout06() {
        Object o = new Object();
        // 0x0000000000000005->101->匿名偏向锁
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        synchronized (o) {
            // 0x00007f94bf00d005->...101->偏向锁
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
        // 0x00007f94bf00d005->...101->偏向锁
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        o.hashCode();
        // 0x0000001da2cb7701->///...001->无锁
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        synchronized (o) {
            // 0x0000700002f10fc0->...000->轻量级锁
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
            o.hashCode();
            // 0x0000700002f10fc0->///...000->轻量级锁
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }
}