Synchronized 的锁升级过程介绍（无锁 --＞ 偏向锁 --＞ 轻量级锁 --＞ 重量级锁 ）

Synchronized 的锁升级过程

1、什么是锁

在并发环境下，多个线程会对同一个资源进行争抢，一些增加或修改数据的操作，就有可能导致数据不一致的问题，为了解决这个问题，所以很多编程语言都引入了锁机制。
通过一种抽象的锁来对资源进行锁定。

1-1：JVM理解：

如图：JVM 运行时内存结构主要包括这些：
JVM 详解

线程私有区域 ： 程序计数器、虚拟机栈、本地方法栈；对于这个区域中的数据，不会出现线程竞争的问题。
虚拟机栈：存放方法、局部变量、方法参数

线程共享区域： Java堆、方法区；这个区域因为是所有线程共享的，所以就存在多个线程同时竞争这些数据，导致出现一些数据一致性的问题。因此需要锁机制对其进行限制。

Java堆：存放对象

方法区：存放类信息、常量

1-2：对象头：

“锁”是一种抽象概念，那么在代码层面是如何实现的？

在Java中，每个Object，就是每个对象，都拥有一把锁，这把锁存放在对象头中，锁中记录了当前对象被哪个线程所占用。

Java对象和对象头的关系：

Java 对象包含3部分内容：对象头、实例数据、填充字节。

对象头中的Mark word：如图：

1-3：synchronized 线程演示数字累加

synchronized 作用是使线程同步

1-3-1：没加锁测试：

num 从 0 开始累加，最终结果应该是 1999 ，这里明显出问题

1-3-2：加 synchronized 锁测试：

在 Java 中，synchronized 使用的是对象级别的锁，也称为内置锁或监视器锁（Monitor Lock）
synchronized 并不是一种特定类型的同步锁，而是 Java 语言内置的一种同步机制，它使用对象级别的锁来确保多线程环境下的数据安全访问。

使用 synchronized 对方法或代码块进行同步；
当一个线程进入 synchronized 方法或代码块时，它会尝试获取对象的锁。如果该锁没有被其他线程占用，该线程就可以进入方法或代码块并执行其中的代码。如果锁已经被其他线程占用，那么该线程就会被阻塞，直到获取到锁为止

创建2个线程同时访问同一个方法，演示多线程下访问同一数据。

2、Synchronized 的锁升级过程

锁为什么要升级？

主要为了应对并发的情况，根据并发量去动态的调节锁的实现（状态）。

比如：比如只有一个线程去获取某个锁的时候，此时这把锁就没有必要太消耗系统的资源，所以肯定就采用最低的系统消耗的一种实现方式。如果随着并发量越来越多，当有很多线程去同时竞争这把锁的时候，那么就得考虑性能的问题，去换一种实现方式，根据并发量去动态的调节锁的实现（状态）。

锁的四种实现（状态）

无锁、偏向锁、轻量级锁、重量级锁

1：无锁

无锁，就是没有锁的实现。

比如：我 new 一个【user】 对象，然后没有使用到 synchronized ，就是无锁。

无锁，就是没有对资源进行锁定，所有线程都能访问到统一资源，这就可能出现两种情况：

1-1：无竞争的情况

某个对象不会出现在多线程环境下，或者即使出现在多线程环境下，也不会出现竞争的情况。那么就无需对这个对象进行任何的保护，直接让这个对象给各个线程调用就可以了。

2-1：存在竞争情况，非锁方式同步线程

资源会被竞争，但是我不想对资源进行锁定，不过还是想通过一些机制来控制多线程。
比如说：

CAS机制:
有多个线程要修改同一个值，我们不通过锁定资源的方式，而是通过其他方式来限制，同时只有一个线程能修改成功，而其他修改失败的线程则不断重试，直到修改成功.

CAS 通过操作系统中的一条指令来实现，所以它就能够保证原子性，通过诸如 CAS 这种方式，我们可以进行无锁编程。

大部分情况下，无锁的效率还是挺高的
原因：
1、减少线程阻塞
2、降低线程切换开销
3、避免锁竞争
4、提高可伸缩性

2：偏向锁

在锁对象的对象头中记录一下当前获取到该锁的线程ID，该线程下次如果又来获取该锁就可以直接获取到了，也就是支持锁重入。

比如：我 new 一个【user】 对象，然后用 synchronized 关键字来锁住这个对象，此时如果只有一个线程来访问这把锁，此时这把锁就是一把偏向锁。

偏向锁主要用来支持可重入锁的实现：

比如：偏向锁会在【user】这个对象的对象头里面记录当前这个线程的 ID ，该线程如果下次又来获取这把锁的这个【user】对象，然后判断这个对象的对象头里面的 ID 是不是当前这个访问线程的 ID，如果是的话，就能重复的获取这把锁，也就能获取到这个【user】对象。

对象头中的 Mark word ：锁状态有32位来表示，如果倒数第3bit是1，则这个锁是偏向锁

3：轻量级锁

当两个或以上的线程 交替 获取锁，但并没有在对象上并发的获取锁时，偏向锁升级为轻量级锁。

轻量级锁的底层实现，是通过 CAS 的自旋方式尝试获取锁，避免阻塞线程造成的 cpu 在用户态和内核态间转换的消耗。

比如：有两个或以上的线程，交替着来获取【user】对象的这把锁，那么刚刚的偏向锁就会升级成轻量级锁。

在操作系统中，用户态和内核态是两种不同的运行级别，用来区分程序在执行时所处的特权级别和访问权限。

用户态： 是程序执行的一种状态，只能访问受限的资源，不能访问底层硬设备等特权指令。
大多数应用程序在用户态下运行，包括常见的应用软件和用户自己编写的程序

内核态： 内核态是操作系统的特权级别，具有对系统资源和硬件的完全访问权限，可以执行所有的指令并直接操作系统内核以及硬件设备。

当程序需要执行特权操作（如访问硬件设备、修改系统参数）时，需要从用户态切换到内核态，这个切换过程称为上下文切换。

上下文切换涉及到保存和恢复进程的上下文信息，开销相对较大，因此尽量避免频繁的用户态和内核态之间的切换，可以提高系统性能。

轻量级锁使用CAS自旋方式尝试获取锁，避免了线程阻塞从而减少了用户态和内核态之间的频繁切换，提高了性能。

4：重量级锁

两个或以上线程 并发 的在同一个对象上进行同步获取时，为了避免无用自旋消耗 cpu，轻量级锁会升级成重量级锁。

比如：有两个或以上的线程，同时并发的来获取【user】对象的这把锁，那么刚刚的轻量级锁就会升级成重量级锁。
就不会去使用 CAS 的自旋锁实现了。
而是通过底层的操作系统来实现这把重量级的锁。
这个过程，就会从用户态，切换到操作系统的内核态。

重量级锁的底层，是通过操作系统提供的互斥锁机制来实现的。
当轻量级锁升级为重量级锁时，会涉及到操作系统层面的资源调度和管理。操作系统会介入并负责锁的管理和调度。
线程在竞争重量级锁时，会进入阻塞状态，操作系统会将这些线程放入一个等待队列中，并在锁可用时唤醒其中的一个线程，让其获取锁并执行临界区的代码（就是被锁修饰的对象或方法的代码）

比如有100个线程去获取这个锁，然后有 99 个线程在自旋的竞争这把锁，那么就很明显的浪费这个cpu的资源，此时升级到重量级锁，到内核态去实现这种互斥，是比较优的方案。

3、如何查看锁的状态

锁，它锁的是对象。

无论是通过 synchronized 代码块修饰对象，还是通过 synchronized 写在方法上，都算是锁对象。synchronized 写在方法上，那么锁的就是 this 对象。

对象的对象头里面存着锁的状态（偏向锁还是轻量锁等），然后就会根据当前这个对象的锁的状态信息来选择不同的实现。
这个状态和实现是同个意思。

4、锁修饰对象和方法的代码

修饰对象：

当synchronized修饰一个对象时，它锁定的是这个对象实例，即当前实例的所有 synchronized 代码块都会受到该锁的影响。

例如：

修饰方法：

当 synchronized 修饰一个方法时，它锁定的是对象实例，即对于该类的所有实例都是同一把锁。

例如：

无论是修饰对象还是方法，synchronized都可以确保在任意时刻，最多只有一个线程可以进入被synchronized修饰的代码块或方法，从而避免多个线程同时修改共享资源导致的数据竞争问题。

5、Synchronized 锁的升级总结

Synchronized 锁升级有四种状态， 无锁 – > 偏向锁 – > 轻量级锁 – > 重量级锁 。

1、比如创建一个 user 对象，没有用 synchronized 关键字来修饰，那么这个对象就是 无锁 的状态。

2、接着用 synchronized 修饰这个对象，如果此时有且只有一个线程多次来获取这个锁，要调用这个对象，那么无锁就会升级为 偏向锁 。

3、接着有两个或两个以上的线程来获取这个锁，但是线程之间是交替来获取这个锁的，交替获取就是指线程A获取到这个锁，操作完再释放后，线程B才会去获取这个锁。这个时候锁就会从偏向锁升级为 轻量级锁 。
轻量级锁的底层实现是通过 CAS 操作来自旋获取锁。

4、接着两个或两个以上的线程，它们是并发同步来获取这个锁的，那么此时的轻量级锁的CAS操作就顶不住了，就会升级为 重量级锁 。

重量级锁的底层，是通过操作系统提供的互斥锁机制来实现的。

当轻量级锁升级为重量级锁时，会涉及到操作系统层面的资源调度和管理。操作系统会介入并负责锁的管理和调度。
线程在竞争重量级锁时，会进入阻塞状态，操作系统会将这些线程放入一个等待队列中，并在锁可用时唤醒其中的一个线程，让其获取锁并执行临界区的代码（就是被锁修饰的对象或方法的代码）