当前位置：首页 > article >正文

Java 锁：多线程环境下的同步机制

article 2025/1/10 16:22:58

一、Java锁简介

在多线程编程中，锁是用来控制多个线程访问共享资源的一种机制，确保同一时刻只有一个线程能访问特定的资源，从而避免数据不一致性、竞争条件等问题。

Java 提供了多种锁机制，既包括内置的锁（如 synchronized），也包括更高级的锁机制（如 ReentrantLock）。

751b67cd-6604-4ace-9ffe-30669f6af173

‍

同步和锁的概念

在 Java 中，同步（Synchronization）是防止多个线程同时访问共享资源的基本手段，确保线程安全。锁则是同步的具体实现之一。

线程安全：当多个线程同时访问某个资源时，保证数据不被破坏，且能够提供正确的执行结果。
临界区：指的是访问共享资源的代码段。在多线程环境下，确保同一时间只有一个线程能够进入临界区。
竞争条件：指多个线程并发执行时，可能会出现对共享资源的错误访问，导致不一致的结果。

‍

据说最初锁的设计灵感来源于火车上的厕所，车上的乘客都可以使用这个厕所，但同一时刻只能有一个人使用。厕所从里面锁住，外面会显示“有人”，没锁会显示“无人”，火车上就用这种方式来控制乘客对厕所的使用。

概念：锁可以确保多个线程之间对共享资源的访问是互斥的，也就是同一时刻只有一个线程能够访问被保护的共享资源，从而避免并发访问带来的数据不一致性和竞态条件等问题，是解决线程安全问题常用手段之一。

接着说厕所，如果没有锁，也就是没有“有人”和“无人”的标识，假如你在里面上厕所，在你用完之前——生活场景：可能会有N个人打开厕所门看看厕所是否空闲。太抽象了，这下知道为什么需要锁了吧😅。

‍

二、发展

Java 锁的演变经历了多个阶段，随着 Java 并发编程模型的不断发展，锁机制也逐渐变得更加丰富和灵活。下面是 Java 锁机制的发展历程。

1. 初期阶段（Java 1.0 - Java 1.1）：基础的同步机制

在 Java 1.0 和 1.1 版本中，Java 提供了最基本的同步机制——synchronized 关键字，这是 Java 中唯一的同步手段。使用 synchronized 可以让线程在执行某些共享资源的代码块时获得排他性访问。

基本原理：每个对象在 Java 中都有一个隐式的锁（也叫对象监视器），使用 synchronized 关键字修饰方法或代码块时，线程在访问这些方法或代码块时需要获得对应对象的锁。
限制：
- 只能确保互斥性（同一时刻只能有一个线程访问共享资源），但无法实现更细粒度的锁控制。
- 不能提供像锁超时、尝试锁定等高级功能。
- 容易发生死锁（Deadlock）等问题。

public synchronized void exampleMethod() {
    // 临界区代码
}

2. Java 1.2 - Java 1.4：`ReentrantLock` 的引入（JUC 包）

随着多核处理器和高并发应用的普及，Java 对并发控制提出了更高的要求。Java 1.2 引入了 java.util.concurrent 包，这是 Java 并发编程库的一个重大改进，它提供了更强大的锁机制，包括显式锁和高级并发控制。

ReentrantLock：ReentrantLock 是 java.util.concurrent.locks 包中提供的显式锁实现，解决了 synchronized 的一些限制（如锁的手动获取、释放等）。它是可重入的，意味着同一线程可以多次获得锁。
显式锁的优势：
- 可中断的锁：使用 lockInterruptibly() 方法可以在等待锁的过程中响应中断。
- 尝试加锁：通过 tryLock() 可以非阻塞地尝试获取锁，避免线程长时间阻塞。
- 可定时加锁：tryLock(long time, TimeUnit unit) 允许线程在指定时间内尝试获取锁。

import java.util.concurrent.locks.ReentrantLock;

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

    public void exampleMethod() {
        lock.lock();  // 获取锁
        try {
            // 临界区代码
        } finally {
            lock.unlock();  // 解锁
        }
    }
}

3. Java 5 - Java 6：并发包的完善和 `ReadWriteLock` 的引入

Java 5 和 Java 6 继续增强并发控制机制，引入了更多的同步工具和锁类型，以适应复杂的并发场景。

ReadWriteLock：ReadWriteLock 允许多个线程同时读取共享资源，但写操作必须是独占的，这对于读操作远多于写操作的场景非常有效，能够提高并发性能。
ReentrantReadWriteLock：这是 ReadWriteLock 的常用实现，它提供了对读和写的互斥控制。
其他并发工具：
- CountDownLatch：用于让一个线程等待多个线程完成任务。
- CyclicBarrier：用于让一组线程在某个点上相互等待，直到所有线程都到达该点。
- Semaphore：用于控制对某个资源的访问权限，允许多个线程同时访问。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class MyClass {
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();

    public void readData() {
        readLock.lock();
        try {
            // 读取共享数据
        } finally {
            readLock.unlock();
        }
    }

    public void writeData() {
        writeLock.lock();
        try {
            // 写入共享数据
        } finally {
            writeLock.unlock();
        }
    }
}

4. Java 7：锁优化和 `StampedLock` 的引入

在 Java 7 中，Java 并发工具库继续扩展，引入了 StampedLock，这是一个比 ReadWriteLock 更高效的锁，它提供了乐观读锁（optimistic read lock）的机制，在读取操作中尽量避免阻塞，提高性能。

StampedLock：
- 允许多线程并发地获取读锁，但它不使用传统的共享/独占模型，而是采用“戳记”机制。它通过提供乐观读锁（tryOptimisticRead()）来减少锁的竞争。
- 在读操作较多且对性能要求较高的场景下，StampedLock 可以比 ReadWriteLock 更加高效。

import java.util.concurrent.locks.StampedLock;

public class MyClass {
    private final StampedLock lock = new StampedLock();

    public void readData() {
        long stamp = lock.tryOptimisticRead();  // 尝试乐观读锁
        try {
            // 读取共享数据
            if (!lock.validate(stamp)) {
                stamp = lock.readLock();  // 如果乐观锁失败，获取读锁
                try {
                    // 读取共享数据
                } finally {
                    lock.unlockRead(stamp);  // 解锁
                }
            }
        } finally {
            // 确保锁的正确释放
        }
    }

    public void writeData() {
        long stamp = lock.writeLock();  // 获取写锁
        try {
            // 写入共享数据
        } finally {
            lock.unlockWrite(stamp);  // 解锁
        }
    }
}

5. Java 8 - Java 9：并发库的进一步增强

Java 8 引入了更多的并发工具，特别是 CompletableFuture 和对函数式编程支持的增强，这有助于简化复杂的并发编程问题。虽然 synchronized 和显式锁（如 ReentrantLock）仍然是主要的同步工具，但 Java 8 提供了更高效的并发工具和更灵活的并发编程模型。

6. Java 9 及以后：并发工具的精细化控制

Java 9 和更高版本继续在并发控制方面进行优化。除了增强的 CompletableFuture、VarHandle 等工具外，锁的语义和实现依旧是并发编程中的核心。

VarHandle：Java 9 引入了 VarHandle，提供了一种对变量进行高效原子操作的新方式，尽管它与传统的锁机制不同，但它对某些高效的并发应用非常有用。
锁的性能和优化：随着 Java 性能优化的进一步发展，JVM 对锁的实现进行了更多的优化，如偏向锁、轻量级锁等机制，以提升锁的性能。

‍

三、特点

Java 锁（包括 synchronized 和显式锁如 ReentrantLock）是并发编程中控制多个线程对共享资源进行访问的重要机制。不同类型的锁具有不同的特点，下面是 Java 锁的主要特点：

1. 互斥性（Mutual Exclusion）

定义：互斥性是指在同一时刻只有一个线程能够访问被锁保护的资源。
表现：锁定对象的线程可以独占该资源，其他线程必须等待该线程释放锁后才能继续执行。
应用：synchronized 和 ReentrantLock 等锁都是通过互斥性来确保线程安全的。

2. 可重入性（Reentrancy）

定义：如果一个线程已经获得某个锁，那么它可以再次获得这个锁，而不会发生死锁。
表现：当同一个线程多次请求一个已经持有的锁时，不会被阻塞，锁的计数器增加，直到释放锁时才会完全释放。
应用：ReentrantLock 和 synchronized 都是可重入的锁。也就是说，如果一个线程已经持有锁，那么它可以在同一代码块中再次获取该锁。

   synchronized void methodA() {
       synchronized (this) {  // 可以在同一个线程中再次获得锁
           // 执行某些操作
       }
   }

3. 非公平性（Fairness）

定义：锁是否按照线程请求的顺序分配。
表现：如果锁是公平的，则线程会按照请求锁的顺序来获取锁；如果锁是非公平的，则任何线程都可以抢占锁，可能会导致一些线程长期无法获得锁（"饥饿"问题）。
应用：ReentrantLock 提供了公平锁的选项，通过构造函数设置 true 来启用公平锁：
```
ReentrantLock lock = new ReentrantLock(true);  // 公平锁
```
默认情况下，ReentrantLock 是非公平锁。synchronized 本身不提供公平锁的支持。

4. 死锁（Deadlock）

定义：死锁是指两个或多个线程因互相持有对方所需的锁而无法继续执行。
表现：在多线程环境中，如果线程 A 持有锁 1 需要锁 2，线程 B 持有锁 2 需要锁 1，就会发生死锁，导致程序无法继续执行。
应用：synchronized 和 ReentrantLock 都可能出现死锁，尤其是当锁的获取顺序不当时。避免死锁的方法包括遵循固定的锁顺序、使用定时锁等。

5. 锁的粒度

定义：锁粒度指的是对共享资源的保护范围。
表现：锁粒度越小，竞争越少，但管理复杂度越高；锁粒度越大，竞争越多，但管理较为简单。
应用：
- 细粒度锁：多个线程竞争同一个大资源时，可以对资源中的细小部分加锁，提高并发度。例如，使用不同的锁保护不同的数据项。
- 粗粒度锁：将整个资源加锁，减少了锁的数量，但可能导致较高的锁竞争。
ReentrantLock 和 synchronized 都可以应用于粗粒度或细粒度锁的场景。

6. 锁的公平性

定义：公平性指的是锁是否按照线程请求的顺序进行分配。
表现：如果锁是公平的，那么线程获取锁的顺序与请求锁的顺序一致。如果锁是非公平的，线程获取锁的顺序可能会有所不同。
应用：
- 公平锁：通过使用 ReentrantLock(true) 可以创建一个公平锁，确保线程按照请求锁的顺序获取锁。
- 非公平锁：ReentrantLock 默认是非公平的，即一个线程可以在等待队列中排在其他线程之前获取锁。

7. 可中断性（Interruptibility）

定义：当线程在等待锁时，如果允许中断，则可以在等待期间响应中断操作。
表现：有些锁机制（如 ReentrantLock）允许线程在尝试获取锁的过程中响应中断，而 synchronized 无法中断一个线程的等待。
应用：
- ReentrantLock 提供了 lockInterruptibly() 方法，允许在等待锁期间响应中断。
- synchronized 是不可中断的，一旦一个线程请求锁并阻塞，它只能在锁可用时继续执行。
```
ReentrantLock lock = new ReentrantLock();
try {
    lock.lockInterruptibly();  // 允许中断
    // 临界区代码
} catch (InterruptedException e) {
    // 处理中断
}
```

8. 锁的性能

定义：不同类型的锁在性能上有差异，通常锁的实现会影响程序的吞吐量和响应时间。
表现：
- 轻量级锁：现代 JVM 引入了轻量级锁和偏向锁来优化锁的性能。通过锁消除和锁粗化等技术，减少了锁的开销。
- 偏向锁：当一个线程多次获得锁时，JVM 会尝试偏向该线程，从而避免每次都加锁和解锁，提高性能。
- 自旋锁：一些锁，如 ReentrantLock，提供自旋锁的机制，即在等待锁时，线程会短时间内重复检查锁是否可用，避免了线程上下文切换的开销。

9. 锁的分段（Lock Splitting）

定义：分段锁是将一个大的锁分解成多个小的锁，允许多个线程并发访问不同的部分。
表现：通过将一个大的锁分解为多个小的锁，减少锁竞争，提高并发性能。
应用：如 ConcurrentHashMap 就使用了分段锁机制。

10. 锁的定时性

定义：锁的定时性是指线程可以在一定时间内尝试获取锁。
表现：某些锁机制（如 ReentrantLock）支持定时锁，允许线程在尝试获取锁时设置超时时间，超时后返回失败而不是一直等待。

应用：

tryLock(long time, TimeUnit unit) 允许线程在给定时间内尝试获取锁，如果超时则返回 false。

boolean locked = lock.tryLock(100, TimeUnit.MILLISECONDS);
if (locked) {
    // 成功获得锁
} else {
    // 超时未获得锁
}

‍

四、分类

在 Java 中，锁可以根据使用方式分为 内置锁（synchronized） 和 显式锁（如 ReentrantLock ）。这两种锁机制都用于多线程并发控制，但它们的实现和使用方式有所不同。

‍

4.1 内置锁（synchronized）

概述

sychronized 是 Java 提供的一种内置锁机制，它通过关键字 synchronized 来标记需要同步的代码块或方法。内置锁由 JVM 自动管理，开发者不需要显式创建和控制锁对象，JVM 会负责锁的获取和释放。

‍

特点

隐式加锁：synchronized 是 Java 提供的语言层级的锁，线程在执行同步代码时自动获取锁，执行完后自动释放锁。开发者不需要显式调用锁的获取和释放方法。
同步代码块/方法：可以修饰实例方法、静态方法、代码块（对象锁、类锁）。
不可中断：一旦线程获得了锁，就会一直持有，直到执行完同步代码后才会释放锁。若锁被其他线程持有，当前线程会被阻塞，直到锁可用。
自动释放锁：当同步代码块执行完毕后，无论是正常执行还是抛出异常，synchronized 会保证锁的释放。

‍

适用场景

简单的线程同步：适用于只需要简单控制并发访问的情况，不需要太多复杂的锁管理。
锁粒度较大：当需要对整个方法或代码块进行同步时，使用 synchronized 很方便。
保证内存可见性和互斥性：synchronized 可以确保在多线程环境下数据的一致性和可见性（通过 Happens-Before 关系）。

‍

局限性

性能问题：在高并发情况下，synchronized 的性能开销较大，特别是在锁竞争激烈时，可能会造成线程阻塞、上下文切换等性能问题。
灵活性差：synchronized 锁机制比较简单，无法像显式锁一样提供更多的灵活操作（例如可中断、超时等）。
不支持尝试锁：无法控制锁的等待时间，线程只能被阻塞等待。

‍

使用方式

同步实例方法（对象锁） ：通过在方法声明上加 synchronized 关键字，使得该方法在同一时刻只能被一个线程访问。
```
public synchronized void method() {
    // 临界区代码
}
```
同步静态方法（类锁） ：当 synchronized 修饰静态方法时，它是针对类本身的锁，即同一个类的所有实例共享这把锁。
```
public static synchronized void staticMethod() {
    // 临界区代码
}
```
同步代码块：synchronized 关键字也可以修饰代码块，允许开发者选择锁定的代码范围。代码块锁需要指定锁对象（通常是共享资源）。
```
public void method() {
    synchronized (this) { // 使用当前对象作为锁
        // 临界区代码
    }
}
```

‍

4.2 显式锁（`ReentrantLock` ）

概述

ReentrantLock 是 Java 提供的一个显式锁，它是 java.util.concurrent.locks.Lock 接口的实现类。与 synchronized 不同，ReentrantLock 需要显式地创建和管理锁对象，提供了比 synchronized 更多的灵活性和控制。

‍

特点

显式加锁：需要程序员手动获取锁和释放锁。通过调用 lock() 方法获取锁，通过调用 unlock() 方法释放锁。
可重入：ReentrantLock 是可重入锁，线程可以多次获取同一把锁，而不会发生死锁。
支持中断：ReentrantLock 提供了 lockInterruptibly() 方法，允许线程在等待锁时响应中断操作。
超时锁：通过 tryLock() 方法，可以尝试在一定的时间内获取锁，如果锁在指定时间内无法获取，线程不会被阻塞，可以选择执行其他操作。
没有隐式释放：与 synchronized 不同，显式锁不会自动释放锁，必须显式调用 unlock() 来释放锁。这就要求开发者确保在锁定的代码块中有正确的释放操作，通常结合 try-finally 块来使用。

‍

适用场景

复杂的同步需求：当需要更细粒度的控制，如超时、可中断等，使用 ReentrantLock 会更加灵活。
锁竞争激烈的场景：ReentrantLock 提供了 tryLock() 和 lockInterruptibly() 等方法，可以避免线程长时间阻塞，提高程序的响应性。
需要公平锁的场景：ReentrantLock 提供了公平锁（new ReentrantLock(true)）的选项，确保请求锁的线程按照请求的顺序来获取锁，避免饥饿现象。

‍

局限性

需要手动管理锁：开发者需要显式地调用 lock() 和 unlock()，如果忘记释放锁，可能会导致死锁或资源泄漏问题。
性能开销：虽然 ReentrantLock 提供了更多的控制，但是它的性能开销可能大于 synchronized，特别是在低并发的场景下。
较复杂的用法：相比 synchronized，ReentrantLock 的使用方式更加复杂，需要注意锁的获取和释放顺序。

‍

使用方式

获取锁：使用 lock() 方法显式获取锁。

Lock lock = new ReentrantLock();
lock.lock();  // 获取锁
try {
    // 临界区代码
} finally {
    lock.unlock();  // 释放锁
}

尝试获取锁：使用 tryLock() 方法，尝试获取锁，如果锁已经被其他线程持有，则立即返回 false。

Lock lock = new ReentrantLock();
if (lock.tryLock()) {
    try {
        // 临界区代码
    } finally {
        lock.unlock();
    }
} else {
    // 如果无法获取锁，执行其他操作
}

支持中断：lockInterruptibly() 允许线程在等待锁时响应中断请求。

Lock lock = new ReentrantLock();
try {
    lock.lockInterruptibly();  // 可中断的锁获取
    // 临界区代码
} catch (InterruptedException e) {
    // 处理中断
} finally {
    lock.unlock();
}

‍

4.3 内置锁与显式锁的比较

特性	内置锁（`synchronized`）	显式锁（`ReentrantLock`）
使用方式	隐式加锁，JVM 自动管理	显式加锁，开发者手动管理
锁的获取	自动获取锁	需要显式调用 `lock()` 获取锁
锁的释放	自动释放锁	需要显式调用 `unlock()` 释放锁
可重入性	支持可重入锁	支持可重入锁
中断响应	不支持中断	支持中断（`lockInterruptibly()`）
超时机制	不支持	支持超时获取锁（`tryLock()`）
性能	在高并发环境中可能存在性能瓶颈	性能灵活，适应高并发场景，但需要小心死锁问题
公平性	不保证公平性	可以设置为公平锁（`new ReentrantLock(true)`）
使用复杂度	使用简单，语法简洁	使用较复杂，需要手动管理锁，且可能会有死锁风险

‍

五、应用场景

Java 锁的应用场景通常与并发编程密切相关。在多线程环境中，锁用于保护共享资源，防止竞态条件、数据不一致和并发修改带来的问题。以下是一些常见的 Java 锁 应用场景，按照不同的并发需求和场景进行分类：

1. 保护共享资源

应用场景：当多个线程访问共享资源（如共享的对象、集合、文件、数据库等）时，需要确保同一时刻只有一个线程可以修改资源，以避免数据不一致或竞态条件。

示例：

在一个多线程环境中，多个线程可能会同时访问一个共享的计数器，如果没有适当的同步，可能导致计数值错误。
使用 synchronized 或 ReentrantLock 来确保计数器的更新是线程安全的。

private int counter = 0;
private final ReentrantLock lock = new ReentrantLock();

public void increment() {
    lock.lock();
    try {
        counter++;
    } finally {
        lock.unlock();
    }
}

2. 避免竞态条件

应用场景：在多线程执行时，如果不同线程同时读取和修改共享变量，可能导致竞态条件（Race Condition），即最终结果依赖于线程执行的顺序。锁可以有效避免竞态条件。

示例：

在一个银行账户类中，多个线程同时对账户余额进行存款和取款操作。若没有同步机制，可能导致余额计算错误。

class BankAccount {
    private int balance = 0;

    public synchronized void deposit(int amount) {
        balance += amount;
    }

    public synchronized void withdraw(int amount) {
        if (balance >= amount) {
            balance -= amount;
        }
    }
}

3. 读写锁（`ReadWriteLock` ）

应用场景：在一些场景下，读取操作远多于写入操作，使用普通的互斥锁可能会造成过度的性能开销。ReadWriteLock 提供了读写分离的锁机制，允许多个线程同时读共享资源，但写操作必须是独占的。

示例：

假设有一个大文件或者数据库，多个线程需要读取文件中的数据，但只允许一个线程进行数据修改。此时可以使用 ReadWriteLock 来提高并发性。

ReadWriteLock lock = new ReentrantReadWriteLock();
Lock readLock = lock.readLock();
Lock writeLock = lock.writeLock();

// 读操作
readLock.lock();
try {
    // 执行读取操作
} finally {
    readLock.unlock();
}

// 写操作
writeLock.lock();
try {
    // 执行写入操作
} finally {
    writeLock.unlock();
}

4. 限制并发数（信号量 `Semaphore` ）

应用场景：当需要限制同时执行的线程数量时，可以使用 Semaphore。例如，在数据库连接池、线程池等场景中，限制同时访问资源的线程数，以避免过多的并发请求导致资源枯竭。

示例：

限制同时执行的线程数，避免过多线程对有限资源（如数据库连接池）造成过载。

Semaphore semaphore = new Semaphore(5);  // 限制最多5个线程并发执行

public void accessResource() throws InterruptedException {
    semaphore.acquire();  // 获取信号量
    try {
        // 执行资源访问操作
    } finally {
        semaphore.release();  // 释放信号量
    }
}

5. 定时任务的同步（`ReentrantLock` 的定时功能）

应用场景：某些场景需要在限定时间内尝试获取锁，避免线程长时间等待或出现死锁。ReentrantLock 提供了 tryLock 方法，可以在特定的时间内尝试获取锁。

示例：

在定时任务调度中，某些线程可能会在指定时间内执行任务，如果某些资源被锁住，可以设置超时等待。

ReentrantLock lock = new ReentrantLock();

boolean isLocked = lock.tryLock(100, TimeUnit.MILLISECONDS);
if (isLocked) {
    try {
        // 执行任务
    } finally {
        lock.unlock();
    }
} else {
    // 超时未能获取锁，执行其他操作
}

6. 防止死锁（死锁检测与避免）

应用场景：死锁是多线程程序中非常常见的问题，多个线程互相等待对方释放锁时会导致程序无法继续执行。通过适当设计锁的顺序和策略，可以避免死锁的发生。

示例：

在数据库操作中，有时多个线程可能会同时访问多个表，若不同线程获取锁的顺序不同，可能会导致死锁。设计时可以采用固定的锁顺序来避免死锁。

public void transfer(Account from, Account to, int amount) {
    synchronized (from) {
        synchronized (to) {
            from.withdraw(amount);
            to.deposit(amount);
        }
    }
}

7. 任务队列与生产者-消费者模型

应用场景：在多线程环境下，经常会使用生产者-消费者模型来协调任务的生产与消费。可以使用 Lock 来控制线程对共享队列的访问，避免线程之间的冲突。

示例：

在任务队列中，生产者生产任务并将其放入队列中，消费者从队列中取任务执行。使用锁来确保队列的线程安全。

class TaskQueue {
    private final Queue<Task> queue = new LinkedList<>();
    private final ReentrantLock lock = new ReentrantLock();

    public void produce(Task task) {
        lock.lock();
        try {
            queue.offer(task);
        } finally {
            lock.unlock();
        }
    }

    public Task consume() {
        lock.lock();
        try {
            return queue.poll();
        } finally {
            lock.unlock();
        }
    }
}

8. 锁的公平性和避免线程饥饿

应用场景：在某些场景下，为了避免线程饥饿（某些线程一直无法获得锁），可以使用公平锁。公平锁确保线程按照请求的顺序来获取锁，避免某些线程长时间无法执行。

示例：

在需要公平访问资源的多线程程序中，使用 ReentrantLock(true) 创建公平锁。

ReentrantLock lock = new ReentrantLock(true);  // 使用公平锁

lock.lock();
try {
    // 执行临界区代码
} finally {
    lock.unlock();
}

9. 资源竞争中的自旋锁

应用场景：在高并发场景下，为了避免线程上下文切换的性能开销，可以使用自旋锁。自旋锁让线程在短时间内通过反复检查锁是否可用来避免阻塞。

示例：

在高并发的小范围资源竞争中，使用自旋锁可以减少线程切换的开销。

// 简单的自旋锁实现
class SpinLock {
    private AtomicBoolean lock = new AtomicBoolean(false);

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

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