Synchronized自旋锁的实现原理及代码详解

Ezageny-Joyous

于 2024-09-29 10:25:17 发布

阅读量1k

点赞数 30

分类专栏： Java 学习文章标签： java

本文链接：https://blog.csdn.net/lssffy/article/details/142617900

版权

学习同时被 2 个专栏收录

279 篇文章 10 订阅

订阅专栏

Java

162 篇文章 3 订阅

订阅专栏

引言

在Java并发编程中，synchronized 是最早出现的同步机制之一。它通过锁机制来确保多线程环境下的线程安全，防止共享资源的竞争。然而，随着现代多核处理器的性能提升和多线程应用需求的增加，Java虚拟机（JVM）对 synchronized 进行了多次优化，其中之一就是自旋锁（spin-lock）的引入。

自旋锁是一种重要的锁优化技术，能够在某些场景下显著提升并发性能。它通过让线程在锁未被获取时自旋等待，而不是直接进入阻塞状态，从而减少线程上下文切换的开销。

本文将深入讲解 synchronized 自旋锁的实现原理，分析其在JVM中的优化机制，并结合代码实例详细展示如何实现自旋锁。通过本文，你将全面理解 synchronized 的自旋机制及其对并发性能的提升作用。

第一部分：`synchronized`的基础概念

1.1 什么是`synchronized`？

synchronized 是Java中用于控制多线程访问共享资源的同步机制。它保证同一时刻只有一个线程能够访问被 synchronized 修饰的代码块或方法，从而防止多个线程同时访问共享资源时产生数据不一致的现象。

synchronized 可以用在以下几种场景中：

修饰实例方法：为当前对象加锁。
修饰静态方法：为当前类对象加锁。
修饰代码块：为特定的对象加锁。

代码示例：synchronized用法

public class SynchronizedExample {
    private int counter = 0;

    // 修饰实例方法
    public synchronized void increment() {
        counter++;
    }

    // 修饰静态方法
    public static synchronized void staticMethod() {
        // 静态方法逻辑
    }

    // 修饰代码块
    public void incrementBlock() {
        synchronized (this) {
            counter++;
        }
    }
}

1.2 锁的工作机制

Synchronized 基于内置锁的概念，也叫做监视器锁（monitor lock）。每个对象都与一个监视器相关联，当某个线程进入 synchronized 修饰的代码块时，它会尝试获取该监视器锁。如果成功获取，其他线程将被阻塞，直到该线程释放锁为止。

Java 中的锁有几种不同的状态：

无锁状态：对象没有被任何线程持有。
偏向锁：如果一个线程多次进入同一个同步块，JVM会为该线程偏向地分配锁，从而避免锁竞争。
轻量级锁：多个线程尝试获取锁时，JVM会将锁膨胀为轻量级锁，尝试减少线程间的竞争。
重量级锁：如果竞争依然激烈，锁会膨胀为重量级锁，线程将被挂起，进入阻塞状态。

第二部分：自旋锁的引入

2.1 自旋锁的概念

自旋锁是一种避免线程立即阻塞的锁机制。当一个线程无法获取锁时，它不会立即进入阻塞状态，而是会进行一定次数的自旋（即忙等待），以检测锁是否可用。这样可以避免频繁的线程上下文切换带来的性能损耗。

自旋锁的核心思想是：当预期锁的等待时间较短时，自旋等待比进入阻塞和恢复运行更有效率。

2.2 为什么需要自旋锁？

在传统的锁机制中，当线程无法获取锁时，线程会进入阻塞状态，而阻塞和恢复线程的操作需要进行上下文切换。这种上下文切换开销很大，尤其是在多核 CPU 上，当锁的竞争较短时，线程的阻塞和恢复可能带来比自旋等待更大的开销。

自旋锁通过让线程自旋等待一段时间，可以避免不必要的上下文切换，从而提升并发性能。

2.3 自旋锁的应用场景

自旋锁并不是适用于所有场景的。它在以下场景中更为适用：

锁竞争时间短：如果锁的持有时间较短，线程自旋等待可以避免不必要的上下文切换。
多核 CPU：在多核 CPU 上，自旋可以利用多核并行计算的优势，减少线程切换的开销。

然而，如果锁的持有时间较长，长时间的自旋会浪费 CPU 资源，导致系统性能下降。因此，JVM 对自旋锁的使用进行了优化，使用了自适应自旋锁（adaptive spin-lock），根据锁的竞争情况动态调整自旋的次数。

第三部分：自旋锁在`synchronized`中的实现

3.1 `synchronized` 的锁优化历程

随着JDK版本的迭代，JVM对synchronized进行了多次优化。其中，自旋锁是JVM对synchronized的一个重要优化。

自 JDK 1.6 起，JVM 引入了自旋锁，并对锁的状态进行了多级优化。具体的优化步骤如下：

偏向锁：如果一个线程多次进入同一个锁，JVM 会为该线程分配偏向锁，避免频繁的锁竞争。
轻量级锁：多个线程尝试竞争同一个锁时，锁会膨胀为轻量级锁，尝试通过 CAS 操作进行无阻塞的获取。
自旋锁：当多个线程尝试获取锁但无法立即获取时，JVM 会让线程自旋等待，而不是立即阻塞。
重量级锁：如果锁竞争激烈，JVM 会将锁膨胀为重量级锁，线程将进入阻塞状态。

3.2 自适应自旋锁的实现

自适应自旋锁是JVM的一个重要优化。在自适应自旋锁中，自旋的次数不再是固定的，而是由前一次自旋的结果和当前锁的状态决定的。

如果一个线程在前一次自旋中成功获取了锁，JVM 会认为锁竞争较轻，下次自旋时会增加自旋的次数。
如果前一次自旋失败，JVM 会减少或直接跳过自旋，进入阻塞状态。

这种自适应机制能够有效减少无效的自旋等待，同时提升系统的整体性能。

3.3 锁升级和自旋锁的实现

JVM 中的锁是轻量级锁与重量级锁之间的过渡状态。以下是自旋锁在 JVM 中的基本流程：

轻量级锁竞争失败：当线程无法通过 CAS（Compare And Swap）获取轻量级锁时，线程不会立刻阻塞，而是自旋等待一段时间，看看锁是否会被释放。
自旋次数判断：自适应自旋锁会根据线程上一次自旋的结果以及当前锁的状态，决定是否继续自旋以及自旋的次数。
锁释放或阻塞：如果在自旋期间，锁被释放，线程可以成功获取锁。如果在多次自旋后仍然无法获取锁，线程将进入阻塞状态。

代码示例：CAS操作和自旋锁原理

自旋锁的实现离不开CAS操作（Compare And Swap），下面我们用CAS操作实现一个简易的自旋锁：

import java.util.concurrent.atomic.AtomicReference;

public class SpinLock {
    // 原子引用，用来保存锁的持有者
    private AtomicReference<Thread> owner = new AtomicReference<>();

    // 加锁方法
    public void lock() {
        Thread currentThread = Thread.currentThread();
        // 自旋等待，直到能够成功获取锁
        while (!owner.compareAndSet(null, currentThread)) {
            // 自旋空转等待
        }
    }

    // 解锁方法
    public void unlock() {
        Thread currentThread = Thread.currentThread();
        owner.compareAndSet(currentThread, null);  // 释放锁
    }
}

class SpinLockTest {
    private static SpinLock spinLock = new SpinLock();

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                spinLock.lock();
                System.out.println(Thread.currentThread().getName() + " acquired the lock.");
                try {
                    Thread.sleep(100);  // 模拟任务执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    spinLock.unlock();
                    System.out.println(Thread.currentThread().getName() + " released the lock.");
                }
            }).start();
        }
    }
}

在这个示例中，我们使用了 AtomicReference 来实现一个简易的自

旋锁。自旋锁通过 compareAndSet 来不断尝试获取锁，如果锁被其他线程持有，当前线程会自旋等待，直到锁被释放。

第四部分：自旋锁的优势与劣势

4.1 自旋锁的优势

避免上下文切换：自旋锁可以避免线程在短期锁竞争中的频繁上下文切换，减少了线程调度器的开销。
适合短期锁竞争：对于锁的持有时间较短的场景，自旋锁可以大大提升系统的并发性能。
减少线程阻塞：通过自旋等待，线程可以避免进入阻塞队列，提升整体的吞吐量。

4.2 自旋锁的劣势

CPU占用高：自旋锁在等待过程中会消耗大量的 CPU 资源，导致系统整体性能下降。
不适合长期锁持有：如果锁的持有时间较长，线程会在自旋期间浪费大量计算资源，最终反而导致性能下降。
可能导致死锁：如果自旋锁设计不当，可能导致死锁等并发问题。

4.3 自适应自旋锁的优化

JVM 中自适应自旋锁通过动态调整自旋次数，解决了自旋锁的部分劣势。它根据锁的竞争情况，动态决定自旋的时长，避免了长时间的无效自旋。

第五部分：如何调优`synchronized`的性能

在实际项目中，我们可以通过以下方式调优synchronized的性能，提升并发处理能力：

5.1 尽量使用代码块而非方法级别锁

使用synchronized代码块可以减少锁的粒度，从而减少锁的竞争。

public void process() {
    synchronized (this) {
        // 仅对必要的代码加锁
        counter++;
    }
}

5.2 避免长时间持有锁

尽量减少锁的持有时间，避免在持有锁时执行耗时操作，如IO或长时间计算。

public void process() {
    synchronized (this) {
        // 快速完成的操作
        counter++;
    }
    // 耗时操作可以放到锁外部
    performTimeConsumingTask();
}

5.3 使用显式锁（ReentrantLock）

对于高并发场景，可以考虑使用ReentrantLock，它支持更多高级功能，如公平锁、可重入锁和条件变量。

import java.util.concurrent.locks.ReentrantLock;

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

    public void performTask() {
        lock.lock();  // 显式加锁
        try {
            // 关键代码
        } finally {
            lock.unlock();  // 确保释放锁
        }
    }
}