高亮的博客

# synchronized

# 问题初形成

预想最终的结果是0，但是出现了预初之外的情况，如负数或者并不是0

@Slf4j
public class Demo {
    static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter++;
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter--;
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",counter);
    }
}

# 分析

Java 中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析
例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令： add

  • 而对应 i-- 也是类似 sub

而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换 Java 内存模型

# 互斥 解决

synchronized注意事项：

  1. 加在普通方法上就是锁的当前this
  2. 在有static方法那么锁的就是类对象

# 语法：

synchronized (对象) {
    临界区    
}

访问修饰符 synchronized 方法名() {
    
}

# 基本使用

在使用 synchronized 对同一把锁的情况下，符合了预期的结果，运行N次都是0

public class Demo {
    static int counter = 0;
    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock) {
                    counter++;
                }
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                synchronized (lock) {
                    counter--;
                }
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",counter);
    }

}

# 语法二：方法

@Slf4j
public class Demo {
    static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                add();
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                sub();
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}",counter);
    }

    public static synchronized void add() {
        counter++;
    }

    public static synchronized void sub() {
        counter--;
    }

}

# synchronized 源码层面分析

# Monitor

# 对象头

以 32 位虚拟机为例

  1. 普通对象 普通对象

  2. 数组对象 数组对象

# Mark Word

  1. hashcode
  2. age：分代年龄，垃圾回收用
  3. biased_lock：偏向锁
    • 0：未启用偏向锁
    • 1：启用
  4. 01，00，10，11：加锁状态
    • 01（Normal）：未加锁，没有跟任何锁关联
    • 10：重量级锁加锁，与Monitor进行关联，关联成功后会把之前的hashcode等等舍弃，变成指向Monitor指针，总的还是32位
    • 00：轻量级锁
    • 11：偏向锁

# 32位

32位Mark Word

# 64位

64位 Mark Word

# Monitor

monitorlijie.png

# 轻量级锁

轻量级锁的使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。
轻量级锁对使用者是透明的，即语法仍然是 synchronized
假设有两个方法同步块，利用同一个对象加锁

static final Object obj = new Object();
public static void method1() {
    synchronized( obj ) {
        // 同步块 A
        method2();
    }
}
public static void method2() {
    synchronized( obj ) {
        // 同步块 B
    }
}
  1. 创建锁记录（Lock Record）对象，每个线程都的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word

img.png

  1. 让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录

img_1.png

  1. 如果 cas 替换成功，对象头中存储了 锁记录地址和状态 00 ，表示由该线程给对象加锁，这时图示如下 img_2.png

  2. 如果 cas 失败，有两种情况

    • 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程
    • 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数 img_3.png

  3. 当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一

img_4.png

  1. 当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头
    • 成功，则解锁成功
    • 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

# 锁膨胀

如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

static Object obj = new Object();
public static void method1() {
    synchronized( obj ) {
        // 同步块
    }
}
  1. 当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁

img.png

  1. 这时 Thread-1 加轻量级锁失败，进入锁膨胀流程
    • 即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址
    • 然后自己进入 Monitor 的 EntryList BLOCKED

img_1.png

  1. 当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null，唤醒 EntryList 中 BLOCKED 线程

# 自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。
当一个线程在尝试加速的时候，发现已经有锁了，就会进入waitlist，在进入之前会尝试一下自选，自选如果成功那么就不用进入waitlist

注意点

  • 自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。
  • 在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。
  • Java 7 之后不能控制是否开启自旋功能

# 偏向锁

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。
Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有

static final Object obj = new Object();
public static void m1() {
    synchronized( obj ) {
        // 同步块 A
        m2();
    }
}

public static void m2() {
    synchronized( obj ) {
    // 同步块 B
       m3();
    }
}

public static void m3() {
    synchronized( obj ) {
         // 同步块 C
     }
}

img.png

img.png

# 偏向状态

一个对象创建时：

  • 如果开启了偏向锁（默认开启），那么对象创建后，markword 值为 0x05 即最后 3 位为 101，这时它的thread、epoch、age 都为 0
  • 偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加 VM 参数，来禁用延迟
XX:BiasedLockingStartupDelay=0
  • 如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001，这时它的 hashcode、age 都为 0，第一次用到 hashcode 时才会赋值

← volatile →