JUC 锁类详解：Java 并发编程的核心锁机制

JUC 锁类详解：Java 并发编程的核心锁机制

Java 并发工具包（JUC）提供了丰富的锁机制，相比传统的 synchronized 关键字，JUC 锁提供了更灵活、更强大的并发控制能力。以下是 JUC 锁类的全面详解：

一、JUC 锁类体系结构

二、核心锁类详解

1. Lock 接口

基础锁操作的核心接口：

public interface Lock {
    void lock();                 // 获取锁
    void lockInterruptibly();    // 可中断获取锁
    boolean tryLock();           // 尝试非阻塞获取锁
    boolean tryLock(long time, TimeUnit unit); // 超时获取锁
    void unlock();               // 释放锁
    Condition newCondition();    // 创建条件变量
}

2. ReentrantLock (可重入锁)

最常用的互斥锁实现：

核心特性：

• 可重入性：同一个线程可多次获取同一把锁
• 公平性选择：支持公平锁和非公平锁
• 可中断的锁获取
• 超时锁获取

使用示例：

Lock lock = new ReentrantLock(); // 默认非公平锁
// Lock lock = new ReentrantLock(true); // 公平锁

lock.lock();
try {
    // 临界区代码
} finally {
    lock.unlock(); // 确保在finally块中释放锁
}

公平锁 vs 非公平锁：

特性	公平锁	非公平锁
获取顺序	按请求顺序获取	允许插队获取
吞吐量	较低	较高
线程唤醒	唤醒等待时间最长的线程	随机唤醒或插队
适用场景	需要严格顺序的场景	大多数高并发场景

3. ReadWriteLock (读写锁)

读写分离的锁实现：

public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}

ReentrantReadWriteLock 实现：

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

// 读操作
readLock.lock();
try {
    // 多个线程可同时读取
} finally {
    readLock.unlock();
}

// 写操作
writeLock.lock();
try {
    // 仅一个线程可写入
} finally {
    writeLock.unlock();
}

锁降级示例：

writeLock.lock(); // 获取写锁
try {
    // 修改数据...
    
    // 锁降级：获取读锁（此时仍持有写锁）
    readLock.lock();
} finally {
    writeLock.unlock(); // 释放写锁，降级为读锁
}

try {
    // 使用读锁读取数据...
} finally {
    readLock.unlock();
}

4. StampedLock (邮戳锁)

Java 8 引入的优化读写锁：

三种访问模式：

1. 写锁：独占锁，类似 ReentrantReadWriteLock.WriteLock
2. 悲观读锁：类似 ReentrantReadWriteLock.ReadLock
3. 乐观读：无锁读取，通过邮戳验证数据一致性

使用示例：

StampedLock stampedLock = new StampedLock();

// 写操作
long stamp = stampedLock.writeLock();
try {
    // 写数据...
} finally {
    stampedLock.unlockWrite(stamp);
}

// 悲观读
long stamp = stampedLock.readLock();
try {
    // 读数据...
} finally {
    stampedLock.unlockRead(stamp);
}

// 乐观读
long stamp = stampedLock.tryOptimisticRead();
// 读取共享数据...
if (!stampedLock.validate(stamp)) {
    // 数据被修改，升级为悲观读锁
    stamp = stampedLock.readLock();
    try {
        // 重新读取数据...
    } finally {
        stampedLock.unlockRead(stamp);
    }
}

5. Condition (条件变量)

线程间协调通信机制：

使用示例（生产者-消费者模型）：

Lock lock = new ReentrantLock();
Condition notFull = lock.newCondition();  // 队列不满条件
Condition notEmpty = lock.newCondition(); // 队列不空条件

// 生产者
lock.lock();
try {
    while (queue.isFull()) {
        notFull.await(); // 等待队列不满
    }
    queue.put(item);
    notEmpty.signal(); // 唤醒消费者
} finally {
    lock.unlock();
}

// 消费者
lock.lock();
try {
    while (queue.isEmpty()) {
        notEmpty.await(); // 等待队列不空
    }
    item = queue.take();
    notFull.signal(); // 唤醒生产者
} finally {
    lock.unlock();
}

三、高级锁技术

1. 锁的优化策略

• 锁粗化：将多个连续的锁请求合并为一个
• 锁消除：JVM 对不可能存在竞争的锁进行消除
• 偏向锁：无竞争时偏向第一个获取锁的线程
• 自旋锁：短时间等待时不挂起线程
• 适应性自旋：根据历史等待时间调整自旋次数

2. AQS (AbstractQueuedSynchronizer)

JUC 锁的底层框架：

AQS 核心组件：

1. 状态变量 (volatile int state)：表示锁的状态
2. FIFO 等待队列：管理等待线程
3. CAS 操作：保证状态更新的原子性

四、锁的性能对比

锁类型	适用场景	吞吐量	公平性	可重入	条件变量
synchronized	简单同步场景	中等	非公平	是	不支持
ReentrantLock	复杂同步控制	高	可选	是	支持
ReentrantReadWriteLock	读多写少	高(读)	可选	是	支持
StampedLock	读多写少，高性能要求	极高	非公平	否	不支持

五、锁的最佳实践

1. 锁范围最小化：

   // 错误做法
   synchronized(this) {
       // 大量非同步代码
       // 少量同步代码
   }
   
   // 正确做法
   // 非同步代码...
   synchronized(this) {
       // 仅同步必要部分
   }
   

2. 避免嵌套锁：

   // 危险：容易导致死锁
   synchronized(lockA) {
       synchronized(lockB) {
           // ...
       }
   }
   

3. 使用 tryLock 避免死锁：

   if (lockA.tryLock(100, TimeUnit.MILLISECONDS)) {
       try {
           if (lockB.tryLock(100, TimeUnit.MILLISECONDS)) {
               try {
                   // 执行操作
               } finally {
                   lockB.unlock();
               }
           }
       } finally {
           lockA.unlock();
       }
   }
   

4. 读写锁选择：

   • 读操作 >> 写操作：使用 StampedLock 或 ReentrantReadWriteLock
   • 写操作频繁：使用 ReentrantLock

5. 锁与内存可见性：

   // 使用锁保证可见性
   lock.lock();
   try {
       sharedVariable = newValue; // 写操作
   } finally {
       lock.unlock();
   }
   
   // 读取时
   lock.lock();
   try {
       return sharedVariable; // 读操作
   } finally {
       lock.unlock();
   }
   

六、常见锁问题解决方案

1. 死锁检测与解决：

   • 使用 jstack 检测死锁
   • 统一锁获取顺序
   • 使用 tryLock 超时机制

2. 活锁问题：

   • 引入随机退避时间

   while (!lock.tryLock()) {
       Thread.sleep(random.nextInt(100)); // 随机退避
   }
   

3. 锁饥饿：

   • 使用公平锁（但会降低吞吐量）
   • 优化锁持有时间

七、锁的监控与诊断

1. JVM 内置监控：

   jstack <pid> # 查看线程锁状态
   jcmd <pid> Thread.print # 打印线程栈
   

2. 可视化工具：

   • JConsole
   • VisualVM
   • Java Mission Control

3. 编程式监控：

   ThreadMXBean bean = ManagementFactory.getThreadMXBean();
   long[] threadIds = bean.findDeadlockedThreads();
   if (threadIds != null) {
       // 处理死锁
   }
   

总结

JUC 锁提供了比传统 synchronized 更灵活、更强大的并发控制能力：

• ReentrantLock：基础互斥锁，支持公平/非公平选择
• ReentrantReadWriteLock：读写分离，优化读多写少场景
• StampedLock：高性能锁，支持乐观读
• Condition：精细化的线程协调机制

在实际开发中，应根据具体场景选择合适的锁：

• 简单同步 → synchronized
• 复杂控制 → ReentrantLock
• 读多写少 → StampedLock 或 ReentrantReadWriteLock
• 线程协调 → Condition

遵循最佳实践，避免死锁和性能问题，结合监控工具确保并发程序的正确性和高性能。