自旋锁讲解

自旋锁原理、特点及优化讲解

原创于 2025-03-24 19:28:20 发布 · 514 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#java #jvm #开发语言

自旋锁（Spin Lock） 是一种基于忙等待（Busy-Waiting）的锁机制，用于在多线程环境中实现资源的互斥访问。与传统的阻塞锁（如 synchronized 或 ReentrantLock）不同，自旋锁在获取锁失败时不会让线程进入阻塞状态，而是通过循环（自旋）不断尝试获取锁，直到成功为止。

1. 自旋锁的核心思想

自旋锁的核心思想是：

当一个线程尝试获取锁时，如果锁已经被其他线程占用，则该线程不会进入阻塞状态，而是通过循环不断尝试获取锁。
这种忙等待的方式避免了线程上下文切换的开销，适用于锁占用时间较短的场景。

2. 自旋锁的实现

自旋锁通常基于 CAS（Compare-And-Swap） 操作实现。以下是一个简单的自旋锁实现：

2.1 基于 CAS 的自旋锁

import java.util.concurrent.atomic.AtomicBoolean;

public class SpinLock {
    private AtomicBoolean locked = new AtomicBoolean(false); // 锁状态

    // 加锁
    public void lock() {
        while (!locked.compareAndSet(false, true)) {
            //
        }
    }

    // 解锁
    public void unlock() {
        locked.set(false);
    }
}

2.2 使用示例

public class SpinLockExample {
    private static SpinLock spinLock = new SpinLock();
    private static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            spinLock.lock(); // 加锁，线程1执行完，直至counter=9999，解锁后线程二才开始执行，线程二一直在尝试获取此锁
            try {
                for (int i = 0; i < 10000; i++) {
                    counter++;
                }
            } finally {
                spinLock.unlock(); // 解锁
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

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

        t1.join();
        t2.join();

        System.out.println("Counter: " + counter); // 输出 20000
    }
}

3. 自旋锁的特点

3.1 优点

无阻塞：线程在获取锁失败时不会进入阻塞状态，避免了上下文切换的开销。
低延迟：适用于锁占用时间较短的场景，能够快速响应。

3.2 缺点

忙等待：线程在自旋过程中会占用 CPU 资源，如果锁占用时间较长，会导致 CPU 资源浪费。
不适用于高竞争场景：在高竞争场景下，自旋锁的性能会显著下降。

4. 自旋锁的适用场景

自旋锁适用于以下场景：

锁占用时间短：锁的占用时间非常短，线程可以快速获取锁。
低竞争：并发访问的线程数量较少，竞争不激烈。
实时性要求高：需要快速响应，不能容忍线程阻塞的开销。

5. 自旋锁与阻塞锁的对比

特性	自旋锁	阻塞锁（如 `ReentrantLock`）
线程状态	忙等待（Busy-Waiting）	阻塞（Blocking）
CPU 占用	高（自旋过程中占用 CPU）	低（线程进入阻塞状态，不占用 CPU）
适用场景	锁占用时间短、低竞争	锁占用时间长、高竞争
实现复杂度	简单（基于 CAS）	复杂（基于 AQS）
性能	低延迟，但可能浪费 CPU	高延迟，但节省 CPU