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

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

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

一、JUC 锁类体系结构

Lock 接口
ReentrantLock
ReentrantReadWriteLock
StampedLock
公平锁/非公平锁
ReadLock
WriteLock
乐观读

二、核心锁类详解

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
ReentrantLock
ReentrantReadWriteLock
CountDownLatch
Semaphore
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. 读写锁选择

    • 读操作 >> 写操作:使用 StampedLockReentrantReadWriteLock
    • 写操作频繁:使用 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
  • 读多写少 → StampedLockReentrantReadWriteLock
  • 线程协调 → Condition

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值