什么是自旋锁？它在并发编程中有何应用？

八股文_Java并发基础题 0 4

参考回答

自旋锁（Spin Lock） 是一种轻量级的锁机制，线程在尝试获取锁时，不会立即阻塞，而是通过循环不断尝试获取锁，直到成功。自旋锁的核心思想是“忙等待”，即在锁可能很快被释放的情况下，通过占用 CPU 时间主动轮询，而不是进入阻塞状态。

自旋锁的特点

忙等待（Busy Waiting）：
- 线程在获取不到锁时会一直循环尝试获取，而不是进入阻塞。
- 消耗 CPU 资源，但避免了线程上下文切换的开销。
适用场景：
- 适合锁竞争较少、持锁时间很短的场景。
- 不适合锁竞争激烈或持锁时间长的场景，因为忙等待会浪费 CPU 资源。
实现方式：
- 通过循环检查某个共享变量的状态实现锁的获取和释放。

自旋锁的实现

1. 简单自旋锁的实现

以下代码展示了一个简单的自旋锁：

import java.util.concurrent.atomic.AtomicBoolean;

public class SpinLock {
    private final AtomicBoolean lock = new AtomicBoolean(false);

    public void lock() {
        while (!lock.compareAndSet(false, true)) {
            // 自旋等待
        }
    }

    public void unlock() {
        lock.set(false); // 释放锁
    }

    public static void main(String[] args) {
        SpinLock spinLock = new SpinLock();

        Runnable task = () -> {
            spinLock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " acquired the lock");
                try {
                    Thread.sleep(1000); // 模拟临界区操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } finally {
                spinLock.unlock();
                System.out.println(Thread.currentThread().getName() + " released the lock");
            }
        };

        Thread t1 = new Thread(task, "Thread-1");
        Thread t2 = new Thread(task, "Thread-2");

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

输出示例：

Thread-1 acquired the lock
Thread-1 released the lock
Thread-2 acquired the lock
Thread-2 released the lock

关键点：

使用 AtomicBoolean 的 compareAndSet 方法保证线程安全。
线程在获取不到锁时通过自旋等待而不是阻塞。

2. 带超时的自旋锁

为避免长时间自旋导致 CPU 资源浪费，可以引入超时时间。

public class TimeoutSpinLock {
    private final AtomicBoolean lock = new AtomicBoolean(false);

    public boolean tryLock(long timeout) {
        long start = System.currentTimeMillis();
        while (!lock.compareAndSet(false, true)) {
            if (System.currentTimeMillis() - start >= timeout) {
                return false; // 超时返回
            }
        }
        return true;
    }

    public void unlock() {
        lock.set(false);
    }

    public static void main(String[] args) {
        TimeoutSpinLock spinLock = new TimeoutSpinLock();

        Runnable task = () -> {
            if (spinLock.tryLock(500)) {
                try {
                    System.out.println(Thread.currentThread().getName() + " acquired the lock");
                    try {
                        Thread.sleep(1000); // 模拟临界区操作
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } finally {
                    spinLock.unlock();
                    System.out.println(Thread.currentThread().getName() + " released the lock");
                }
            } else {
                System.out.println(Thread.currentThread().getName() + " failed to acquire the lock");
            }
        };

        Thread t1 = new Thread(task, "Thread-1");
        Thread t2 = new Thread(task, "Thread-2");

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

输出示例：

Thread-1 acquired the lock
Thread-2 failed to acquire the lock
Thread-1 released the lock

自旋锁的优缺点

优点

避免线程阻塞：

自旋锁不会让线程进入阻塞状态，避免了线程上下文切换的开销。

适合短时间持锁场景：

锁的持有时间较短时，自旋锁可以显著提高性能。

缺点

忙等待的开销：

如果锁被长时间占用，自旋锁会浪费大量 CPU 资源。

不适合高并发场景：

高并发时，多个线程忙等待会导致 CPU 使用率飙升。

无公平性：

默认实现中，自旋锁无法保证线程获取锁的公平性，可能导致某些线程长期无法获取锁。

自旋锁的应用场景

适用场景

短临界区：锁的持有时间非常短，例如计数器累加。
低线程竞争：锁竞争不激烈时，自旋锁性能优于阻塞锁。
硬件加速：某些场景下，硬件支持的自旋锁（如 JVM 内部锁）性能更优。

不适用场景

长时间持锁：如锁的持有时间较长，使用自旋锁会浪费大量 CPU 时间。
高并发环境：线程数量较多时，自旋锁的忙等待会导致严重的性能问题。

自旋锁在 Java 并发中的应用

AtomicInteger 和 CAS 操作
- Java 的原子类（如 AtomicInteger）使用 CAS（Compare-And-Swap）实现内部的自旋锁操作。
ReentrantLock 的自旋优化
- 在竞争不激烈的情况下，ReentrantLock 的非公平锁使用自旋机制尝试快速获取锁。
JVM 内部的锁优化
- JVM 的偏向锁和轻量级锁使用了类似自旋锁的机制，减少了线程切换的开销。

总结

自旋锁的概念：一种轻量级的锁，通过忙等待避免线程阻塞。
核心机制：线程在获取锁时不断轮询共享变量的状态，通过 CAS 保证线程安全。
适用场景：短时间持锁、低线程竞争的场景。
使用注意：
- 自旋时间过长会浪费 CPU 资源。
- 可结合超时机制避免过度忙等待。
在并发编程中的应用：被广泛用于 CAS 操作、JVM 内部锁优化等场景。