JAVA高并发业务中ReentrantLock导致锁饥饿问题的实战修复

Java高并发业务中ReentrantLock导致锁饥饿问题的实战修复

大家好，今天我们来聊一聊在高并发Java业务中，ReentrantLock导致的锁饥饿问题，并结合实际案例分析和修复策略。 ReentrantLock作为Java并发包中一个强大的工具，提供了比synchronized更灵活的锁机制，但也更容易在使用不当的情况下引发锁饥饿。

1. 什么是锁饥饿？

锁饥饿是指在高并发环境中，某些线程由于调度策略或者锁竞争的原因，长时间无法获得所需的锁，导致无法执行任务。这种情况会严重影响系统的响应速度和吞吐量，甚至导致系统假死。

想象一下，餐厅只有一个厨师（锁），很多顾客（线程）都在排队点餐。如果厨师总是优先处理VIP顾客（高优先级线程）的订单，普通顾客（低优先级线程）可能需要等待很长时间才能得到服务，甚至等到餐厅关门都还没轮到自己。这就是一个简单的锁饥饿场景。

2. ReentrantLock 与锁饥饿

ReentrantLock默认情况下是非公平锁。这意味着当锁被释放时，等待队列中的线程并不是按照先来后到的顺序竞争锁，而是由JVM随机选择一个线程获得锁。在高并发环境下，如果总是有新的线程尝试获取锁，那么等待时间较长的线程可能永远无法获得锁，从而导致饥饿。

2.1 非公平锁的特性

非公平锁的优势在于吞吐量较高。因为新来的线程可以直接尝试获取锁，而无需排队，减少了上下文切换的开销。但是，这种机制也带来了饥饿的风险。

2.2 ReentrantLock 的公平锁

ReentrantLock提供了公平锁的选项。通过在构造函数中传入true，可以将锁设置为公平锁。

ReentrantLock fairLock = new ReentrantLock(true); // 创建一个公平锁

公平锁会按照线程请求锁的顺序来分配锁，保证等待时间最长的线程优先获得锁。这可以避免饥饿问题，但也会降低吞吐量，因为每个线程都需要排队等待。

3. 实战案例：电商秒杀系统

我们以一个电商秒杀系统为例，来模拟锁饥饿的场景。假设系统使用ReentrantLock来控制库存的扣减。

3.1 模拟代码

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

public class Seckill {

    private int stock = 10; // 库存数量
    private ReentrantLock lock = new ReentrantLock(); // 默认非公平锁

    public void purchase() {
        try {
            lock.lock();
            if (stock > 0) {
                // 模拟扣减库存的耗时操作
                Thread.sleep(10);
                stock--;
                System.out.println(Thread.currentThread().getName() + " 购买成功，剩余库存：" + stock);
            } else {
                System.out.println(Thread.currentThread().getName() + " 购买失败，库存不足");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Seckill seckill = new Seckill();
        ExecutorService executor = Executors.newFixedThreadPool(20); // 创建20个线程

        for (int i = 0; i < 100; i++) {
            executor.execute(seckill::purchase);
        }

        executor.shutdown();
    }
}

在这个代码中，我们创建了一个Seckill类，模拟秒杀场景。purchase()方法使用ReentrantLock来保证库存扣减的原子性。我们创建了20个线程来模拟高并发请求。

3.2 观察锁饥饿现象

运行上述代码，你可能会发现，某些线程能够连续多次购买成功，而另一些线程则始终无法获得锁，一直提示“购买失败，库存不足”。这就是锁饥饿的现象。

3.3 使用JConsole或VisualVM进行监控

可以使用JConsole或VisualVM等工具来监控线程的运行状态，观察是否有线程长时间处于等待锁的状态。

4. 修复方案

4.1 使用公平锁

最直接的修复方案是将ReentrantLock设置为公平锁。

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

修改代码后重新运行，你会发现，每个线程都有机会获得锁，避免了锁饥饿的问题。但是，吞吐量可能会有所下降。

4.2 优化锁的粒度

如果锁的范围过大，会导致更多的线程竞争锁，增加锁冲突的可能性。可以通过缩小锁的粒度来减少锁竞争。

例如，可以将库存扣减操作分解为多个步骤，只对关键步骤进行加锁。

public void purchase() {
    // ... 一些其他的操作，不需要加锁

    boolean success = false;
    try {
        lock.lock();
        if (stock > 0) {
            // 模拟扣减库存的耗时操作
            Thread.sleep(10);
            stock--;
            success = true;
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
        if(success){
            System.out.println(Thread.currentThread().getName() + " 购买成功，剩余库存：" + stock);
        }else{
            System.out.println(Thread.currentThread().getName() + " 购买失败，库存不足");
        }
    }

    // ... 一些其他的操作，不需要加锁
}

4.3 使用其他的并发工具

除了ReentrantLock，Java并发包还提供了许多其他的并发工具，例如Semaphore、CountDownLatch、CyclicBarrier等。根据具体的业务场景，选择合适的并发工具可以更好地解决并发问题。

对于库存扣减场景，可以使用AtomicInteger来实现原子性的减操作，避免使用锁。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class SeckillAtomic {

    private AtomicInteger stock = new AtomicInteger(10); // 库存数量

    public void purchase() {
        if (stock.get() > 0) {
            // 使用compareAndSet原子性地扣减库存
            if (stock.compareAndSet(stock.get(), stock.get() - 1)) {
                // 模拟扣减库存的耗时操作
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 购买成功，剩余库存：" + stock.get());
            } else {
                purchase(); // 重试
            }
        } else {
            System.out.println(Thread.currentThread().getName() + " 购买失败，库存不足");
        }
    }

    public static void main(String[] args) {
        SeckillAtomic seckill = new SeckillAtomic();
        ExecutorService executor = Executors.newFixedThreadPool(20); // 创建20个线程

        for (int i = 0; i < 100; i++) {
            executor.execute(seckill::purchase);
        }

        executor.shutdown();
    }
}

4.4 使用队列缓冲

在高并发场景下，可以将请求放入队列中进行缓冲，然后由消费者线程从队列中取出请求进行处理。这可以减少锁竞争的压力，提高系统的吞吐量。

可以使用BlockingQueue来实现队列缓冲。

5. 最佳实践

实践	描述	优点	缺点
使用公平锁 (ReentrantLock(true))	确保所有线程按照请求锁的顺序获得锁。	避免锁饥饿，保证公平性。	吞吐量可能较低，因为线程必须排队等待。
优化锁的粒度	尽量缩小锁的范围，只对关键代码段加锁。	减少锁竞争，提高并发性能。	需要仔细分析代码，确定需要加锁的关键代码段，增加了代码复杂性。
使用原子类 (AtomicInteger, etc.)	使用原子类进行原子操作，避免使用锁。	无锁操作，性能更高，避免了锁竞争和死锁的风险。	适用场景有限，只能用于简单的原子操作。
使用并发集合 (ConcurrentHashMap, etc.)	使用并发集合代替普通的集合，避免使用锁。	并发集合内部实现了线程安全，性能更高。	适用场景有限，需要根据具体的业务场景选择合适的并发集合。
使用队列缓冲 (BlockingQueue)	将请求放入队列中进行缓冲，然后由消费者线程从队列中取出请求进行处理。	减少锁竞争的压力，提高系统的吞吐量，实现流量削峰。	增加了系统的复杂性，需要维护队列的状态和消费者线程的生命周期。
避免长时间持有锁	尽量减少持有锁的时间，避免阻塞其他线程。	减少锁竞争，提高并发性能。	需要仔细分析代码，优化代码逻辑，减少持有锁的时间。
使用读写锁 (ReadWriteLock)	当读操作远多于写操作时，可以使用读写锁来提高并发性能。	允许多个线程同时读取共享资源，只有在写操作时才需要互斥访问，提高了并发性能。	适用场景有限，只有在读多写少的情况下才能发挥优势。
使用StampedLock	在JDK8中引入，相比于ReadWriteLock，StampedLock提供了更灵活的读写锁控制，可以避免读写锁的饥饿问题，但在使用时需要更加小心，以避免死锁。	性能通常优于ReadWriteLock，尤其是在读取频繁的场景下。可以实现乐观读，减少锁的竞争。	使用更加复杂，需要手动管理锁的状态，不当使用可能导致死锁或活锁。
使用锁分离	将一个锁拆分成多个锁，每个锁保护不同的资源，减少锁竞争。	可以进一步缩小锁的粒度，提高并发性能。	需要仔细分析代码，确定可以分离的资源，增加了代码复杂性。
锁粗化	将多个相邻的锁合并成一个锁，减少锁的获取和释放的开销。	减少锁的开销，提高性能。	需要仔细分析代码，确保合并后的锁不会增加锁竞争。
使用无锁数据结构	使用无锁数据结构，例如ConcurrentLinkedQueue，ConcurrentSkipListMap等，避免使用锁。	无锁操作，性能更高，避免了锁竞争和死锁的风险。	适用场景有限，需要根据具体的业务场景选择合适的无锁数据结构。
使用CAS操作	使用CAS (Compare and Swap) 操作进行原子更新，避免使用锁。	无锁操作，性能更高，避免了锁竞争和死锁的风险。	适用场景有限，需要处理CAS操作失败的情况，例如自旋重试。
使用ThreadLocal	使用ThreadLocal为每个线程创建一个独立的变量副本，避免多个线程访问同一个变量。	减少了线程之间的竞争，提高了并发性能。	会增加内存消耗，需要注意ThreadLocal变量的清理，避免内存泄漏。

6. 注意事项

• 选择合适的锁策略： 根据具体的业务场景，选择合适的锁策略。如果对公平性要求较高，可以选择公平锁。如果对吞吐量要求较高，可以选择非公平锁。
• 避免长时间持有锁： 尽量减少持有锁的时间，避免阻塞其他线程。
• 监控锁的竞争情况： 使用JConsole或VisualVM等工具来监控锁的竞争情况，及时发现和解决问题。

7. 总结

通过以上的分析和实践，我们了解了ReentrantLock导致的锁饥饿问题，并学习了多种修复方案。在实际开发中，需要根据具体的业务场景，选择合适的锁策略，并进行性能测试和监控，才能有效地解决锁饥饿问题，提高系统的并发性能。

高并发业务中的锁问题和优化

• 锁饥饿是高并发场景中常见的问题，ReentrantLock默认的非公平锁更容易导致饥饿。
• 解决饥饿问题需要权衡公平性和吞吐量，并根据实际情况选择合适的并发工具和优化策略。
• 持续监控和性能测试是保证高并发系统稳定性的关键。