Java中的自旋锁（SpinLock）详解

1. 自旋锁的基本概念

自旋锁是一种轻量级的锁机制，当线程尝试获取锁失败时，不会立即阻塞（进入等待状态），而是通过循环（自旋） 不断尝试获取锁，直到成功为止。这种机制适用于锁占用时间极短的场景，能减少线程上下文切换的开销。

核心特点：

• 通过CPU空转（循环）避免线程切换；
• 适用于多核环境，且锁竞争不激烈的场景；
• 若锁被长期占用，自旋会浪费CPU资源。

2. 自旋锁的实现原理

自旋锁的本质是通过原子操作（如CAS）竞争锁状态。以下是一个简单的自旋锁实现示例：

import java.util.concurrent.atomic.AtomicReference;

public class SpinLock {
    private AtomicReference<Thread> owner = new AtomicReference<>();

    public void lock() {
        Thread current = Thread.currentThread();
        // 自旋等待直到成功将owner设置为当前线程
        while (!owner.compareAndSet(null, current)) {
            // 空循环，也可加入Thread.yield()或短时间休眠优化
        }
    }

    public void unlock() {
        Thread current = Thread.currentThread();
        // 只有锁的持有者才能释放锁
        owner.compareAndSet(current, null);
    }
}

步骤解析：

1. 加锁过程：

   • 线程通过compareAndSet(null, current)尝试将owner从null改为自身引用；
   • 若失败（锁已被其他线程占用），则循环重试（自旋）；
   • 成功则退出循环，进入临界区。

2. 解锁过程：

   • 线程将owner从自身引用改回null，允许其他线程竞争。

3. 自旋锁的优化策略

3.1 适应性自旋锁

JVM中的自旋锁（如synchronized的轻量级锁）会动态调整自旋次数：

• 若上次自旋成功获取锁，则下次允许更长的自旋时间；
• 若自旋很少成功，则直接跳过自旋，避免CPU浪费。

3.2 公平性优化

基础自旋锁是非公平的，可能导致线程饥饿。可通过队列（如CLH锁）实现公平自旋：

// 简化的CLH锁示例
public class CLHLock {
    private final AtomicReference<Node> tail = new AtomicReference<>(new Node());
    private final ThreadLocal<Node> myNode = ThreadLocal.withInitial(Node::new);
    private final ThreadLocal<Node> myPred = new ThreadLocal<>();

    public void lock() {
        Node node = myNode.get();
        node.locked = true; // 当前线程准备获取锁
        Node pred = tail.getAndSet(node); // 将自身节点插入队列尾部
        myPred.set(pred);
        while (pred.locked) {} // 自旋等待前驱节点释放锁
    }

    public void unlock() {
        Node node = myNode.get();
        node.locked = false; // 释放锁，通知后继节点
        myNode.set(myPred.get()); // 重置当前节点
    }

    private static class Node {
        volatile boolean locked;
    }
}

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

5. JVM中的自旋锁应用

在HotSpot虚拟机中，自旋锁主要用于以下场景：

1. 轻量级锁竞争：当线程尝试获取轻量级锁时，会先进行短时间自旋；
2. 偏向锁撤销：当持有偏向锁的线程不在同步块内，其他线程会通过自旋等待锁撤销；
3. JUC工具类：如AtomicInteger的底层CAS操作本质是自旋。

6. 自旋锁的注意事项

1. 自旋时间限制：避免无限自旋，JVM默认自旋次数为10次（可通过-XX:PreBlockSpin调整）；
2. 结合系统调度：在单核CPU上，自旋可能需配合Thread.yield()让出CPU；
3. 锁升级机制：若自旋失败，JVM会将锁升级为重量级锁（如synchronized的膨胀过程）。

总结：自旋锁通过“忙等待”替代线程阻塞，在特定场景下能显著提升性能，但需合理评估锁竞争强度，避免CPU资源浪费。实际开发中，通常直接使用JUC包中的工具类（如ReentrantLock），其内部已集成自适应自旋策略。