锁的优化机制（偏向锁、自旋锁、轻量级锁、重量级锁）

锁的状态从低到高依次为无锁->偏向锁->轻量级锁->重量级锁，升级的过程就是从低到高，降级在一定条件也是有可能发生的，优化机制包括自适应锁、自旋锁、锁消除、锁粗化、轻量级锁和偏向锁。
这边主要以synchronized、ReentrantLock两种实现方式来说明 偏向锁、自旋锁、轻量级锁、重量级锁

一、偏向锁

基本概念

当线程访问同步块获取锁时，会在对象头和栈帧中的锁记录里存储偏向锁的线程ID，之后这个线程再次进入同步块时都不需要CAS来加锁和解锁了，偏向锁会永远偏向第一个获得锁的线程，如果后续没有其他线程获得过这个锁，持有锁的线程就永远不需要进行同步，反之，当有其他线程竞争偏向锁时，持有偏向锁的线程就会释放偏向锁。

基本实现

对于synchronized，偏向锁就用设置-XX:+UseBiasedLocking开启偏向锁

对于ReentrantLock，new ReentrantLock(false)（非公平锁）设置参数为false创建的是偏向锁

当偏向锁的获取出现竞争，则偏向锁可能会升级为轻量级锁，偏向锁适用于无竞争、竞争小的场景。

二、自旋锁

基本概念

自旋的概念主要就是一个忙等待，等待获取到锁后再进行下一步操作。

基本实现

对于synchronized，自旋锁可以通过设置-XX:+UseSpining来开启，自旋的默认次数是10次，可以使用-XX:PreBlockSpin设置。

对于ReentrantLock，通过逻辑设置忙等待处理，以下是示例。

import java.util.concurrent.locks.ReentrantLock;

/**
 * 自旋锁
 */
public class SpinLockExample {
    private static int count = 0;
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                try {
                    while (!lock.tryLock()) {
                        // 自旋等待获得锁
                    }
                    count++;
                } finally {
                    lock.unlock();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                try {
                    while (!lock.tryLock()) {
                        // 自旋等待获得锁
                    }
                    count++;
                } finally {
                    lock.unlock();
                }
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + count);
    }
}

三、轻量级锁

基本概念

在轻量级锁状态下继续锁竞争，如果成功就成功获取轻量级锁。否则进入锁膨胀阶段，没有抢到锁的线程将自旋，即不停地循环判断锁是否能够被成功获取。长时间的自旋操作是非常消耗资源的，一个线程持有锁，其他线程就只能在原地空耗CPU，执行不了任何有效的任务，这种现象叫做忙等（busy-waiting）。如果锁竞争情况严重，某个达到最大自旋次数的线程，会将轻量级锁升级为重量级锁。

基本实现

当synchronized所修饰的方法所访问的对象是静态对象时，确实可以认为它是轻量级锁。因为静态对象在类加载时被加载到方法区，并且只会被加载一次。当多个线程访问静态方法时，由于它们访问的是同一个静态对象，所以实际上只有一个线程能够进入同步块，从而实现轻量级锁的效果。

ReentrantLock默认使用的是轻量级锁。但是，当锁被频繁地获取和释放，或者在锁竞争的情况下，ReentrantLock 会将轻量级锁升级为重量级锁，以避免锁竞争和提高性能。

四、重量级锁

基本概念

重量级锁即是需要排队竞争锁，当锁被占用时则需要挂起，等待锁释放后唤醒线程竞争获取锁。在锁资源被占用时会进行同步操作，以确保只有一个线程能够访问锁资源。

基本实现

当使用 synchronized 关键字时，如果锁对象是一个实例对象，那么就是重量级同步。这种同步方式会涉及到锁对象的实例化，需要将锁对象的状态存储在内存中，因此占用大量的系统资源，性能较低。（自动切换轻量级锁和重量级锁）

对于ReentrantLock，以下是示例。

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int counter = 0;

    public void incrementCounter() {
        lock.lock(); // 获取锁
        try {
            counter++;
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    public int getCounter() {
        return counter;
    }
}

当多次调用 incrementCounter() 方法时，如果锁没有被其他线程占用，那么 ReentrantLock 会自动重入锁，不会导致死锁。但如果锁被其他线程占用，那么 ReentrantLock 会将轻量级锁升级为重量级锁，从而避免锁竞争，提高性能。

五、锁粗化、锁消除

锁粗化

锁粗化指的是有很多操作都是对同一个对象进行加锁，就会把锁的同步范围扩展到整个操作序列之外。（指在某些情况下，放宽对锁的使用限制（简而言之原本需要上多个锁的或者其他地方也需要上锁，干脆就融合成一个范围的锁，减少限制条件），从而避免死锁的发生）
例如：可以ReentrantLock使用公平锁来保证等待锁释放的线程按照请求锁的顺序来释放锁，从而避免死锁的发生，同时也可以通过减少锁的使用时间、优化锁的同步策略等方法来避免死锁的发生。

锁消除

锁消除指的是JVM检测到一些同步的代码块，完全不存在数据竞争的场景，也就是不需要加锁，就会进行锁消除。

六、优缺点对比

借用下别的博主的总结

复习阶段可能个人理解不一定准确，有问题望大家指出，谢谢❀