synchronized实现原理总结

实现原理

基于对象头的MarkWord存储锁状态，实现获取锁，释放锁以及锁升级

所以首先要了解对象头，在未开启指针压缩情况下:
对象头 = 8byte的MarkWord + 8byte的ClassPointer
开启指针压缩后：
对象头 = 8byte的MarkWord + 4byte的ClassPointer + 4byte的对齐数据
对齐是因为64位的JVM寻址空间是8byte，必须为8byte的整数倍

以下程序可以验证：JDK8自动开启指针压缩
关闭指针压缩：-XX:-UseCompressedOops

测试代码

import org.openjdk.jol.info.ClassLayout;

/**
 * 测试对象头
 */
public class T14_Object_Header {
    public static void main(String[] args){
        Object o = new Object();
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
    }
}

JVM源码中锁在对象头上的标识枚举

enum {   locked_value             = 0,//00 轻量级锁
         unlocked_value           = 1,//01 无锁
         monitor_value            = 2,//10 监视器锁，也叫膨胀锁，也叫重量级锁
         marked_value             = 3,//11 GC标记
         biased_lock_pattern      = 5 //101 偏向锁
};

锁升级

无锁：刚new出来的对象，无任何锁竞争
偏向锁：一段同步代码一直被一个线程所访问，对象会在对象头上标识该线程，那么该线程会自动获取到锁
自旋锁：多个线程竞争同步代码，会以自旋和CAS的方式获取对象的锁
重量级锁：CAS竞争激烈，升级到操作系统的申请锁，由操作系统决定是否获取到锁

测试代码

JDK6后默认开启偏向锁，但是会延时加载，使用JVM参数取消延时加载

-XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0

import org.openjdk.jol.info.ClassLayout;

/**
 * 测试锁升级   -XX:+UseBiasedLocking -XX:BiasedLockingStartupDelay=0
 */
public class T14_Object_Header_None_Lock {
    public static void main(String[] args) throws InterruptedException {
        Object o = new Object();
        System.out.println("before lock");
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        synchronized (o) {
            System.out.println("locking...........");
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
        System.out.println("after lock");
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
    }
}

获取偏向锁和撤销偏向锁流程

自旋锁升级重量级锁流程

CAS原理

操作：CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。如果A=V，那么把B赋值给V，返回V；如果A！=V，直接返回V
实现：JNI调用native方法：unsafe.compareAndSwapInt(this, valueOffset, expect, update);
底层：lock cmpxchg指令，lock用于多CPU情况下保证单CPU执行操作，cmpxchg用于比较替换

synchronized的特性

原子性和可见性：多个线程是同步的方式访问临界区的，所以具有天然的原子性和可见性
可重入：如果是一个同步方法调用另外一个同步方法，有一个方法加了锁，另外一个方法也需要加锁，加的是同一把锁也是同一个线程，那这个时候申请仍然会得到该对象的锁
不可逆：锁升级的流程是不可逆转的

synchronized的用法

同步代码块和同步方法

package com.example.code.juc;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class T15_Sync {
    private int count1 = 10;
    private int count2 = 10;

    public void m1() {
        synchronized (this) {
            count1--;
            System.out.print("count = " + count1 + "   ");
        }
    }

    public synchronized void m2() {
        count2--;                            // 等价 synchronized (this)
        System.out.print("count = " + count2 + "   ");
    }


    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        T15_Sync t = new T15_Sync();
        for (int i = 0; i < 10; i++) {
            executorService.submit(new Thread(t::m1, "t" + i + "m1"));
        }

        executorService.awaitTermination(3, TimeUnit.SECONDS);
        System.out.println("m1结束！！！");


        for (int i = 0; i < 10; i++) {
            executorService.submit(new Thread(t::m2, "t" + i + "m2"));
        }

        executorService.awaitTermination(3, TimeUnit.SECONDS);
        System.out.println("m2结束！！！");
    }
}

同步静态方法

package com.example.code.juc;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class T16_Sync {
    private static int count3 = 10;
    private static int count4 = 10;

    public static void m3() {
        synchronized (T16_Sync.class) {
            count3--;
            System.out.print("count = " + count3 + "   ");
        }
    }

    public synchronized static void m4() {   // 等价 synchronized (T01_Synchronized.class)
        count4--;
        System.out.print("count = " + count4 + "   ");
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 10; i++) {
            executorService.submit(new Thread(() -> {
                T16_Sync.m3();
            }, "t" + i + "m3"));
        }

        executorService.awaitTermination(3, TimeUnit.SECONDS);
        System.out.println("m3结束！！！");

        for (int i = 0; i < 10; i++) {
            executorService.submit(new Thread(() -> {
                T16_Sync.m4();
            }, "t" + i + "m4"));
        }

        executorService.awaitTermination(3, TimeUnit.SECONDS);
        System.out.println("m4结束！！！");
    }
}