synchronized实战：synchronized 锁升级过程

下面程序通过对加锁前后Object对象字节码的打印验证了对象由无锁到偏向锁的过程。

public class T01 {
    public static void main(String[] args) {
        Object o = new Object();
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        o.hashCode();
        System.out.println(ClassLayout.parseInstance(o).toPrintable());
        synchronized (o){
            System.out.println(ClassLayout.parseInstance(o).toPrintable());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

运行上面程序，输出结果如下

Java 中的synchronized锁升级过程实际上是锁的粗化（Coarsening）和锁的细化（Fine-grained Locking）之间的权衡过程。锁升级的过程会根据执行情况来动态调整锁的粒度，以优化性能。下面是一个简单的程序示例，演示了锁的升级过程：

public class LockUpgradeDemo {

    private static final Object lock = new Object();

    public static void main(String[] args) {
        // 启动两个线程
        Thread thread1 = new Thread(new CoarseLockTask());
        Thread thread2 = new Thread(new FineGrainedLockTask());

        thread1.start();
        thread2.start();
    }

    // 粗粒度锁任务
    static class CoarseLockTask implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                System.out.println("Coarse-grained Lock: Start");

                try {
                    Thread.sleep(1000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("Coarse-grained Lock: End");
            }
        }
    }

    // 细粒度锁任务
    static class FineGrainedLockTask implements Runnable {
        @Override
        public void run() {
            System.out.println("Fine-grained Lock: Start");

            synchronized (lock) {
                try {
                    Thread.sleep(500); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("Fine-grained Lock: Inside synchronized block");
            }

            System.out.println("Fine-grained Lock: End");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

在这个示例中，有两个线程，一个使用粗粒度锁（CoarseLockTask），另一个使用细粒度锁（FineGrainedLockTask）。粗粒度锁在执行期间持有锁，而细粒度锁在执行期间释放了锁，然后重新获取了锁。

运行这个程序，你会看到两个线程的输出交错进行，其中细粒度锁的输出在粗粒度锁的输出中间。这演示了锁的升级过程，其中锁会根据实际执行情况在粗粒度和细粒度之间动态切换，以提高性能。

请注意，实际的锁升级过程是由JVM和编译器进行管理和优化的，程序员通常无需手动干预。这个示例只是为了演示锁升级的概念。