Java 常见锁类型及适用场景详解

2. 显式锁（Lock 接口）- 手动锁

核心定义

JUC 包下 java.util.concurrent.locks.Lock 接口的实现类，手动加锁 / 释放锁（需在 finally 中释放，避免死锁），是 synchronized 的补充和增强。

核心实现类 & 特点

适用场景

• 需要灵活锁控制（如可中断、超时获取锁、公平锁）的场景；
• 读多写少的高并发场景（选 ReentrantReadWriteLock/StampedLock）；
• 高并发、需要精细控制锁生命周期的场景。

代码示例（ReentrantLock）

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
    // 公平锁（按请求顺序获取），默认非公平锁（性能更高）
    private static final ReentrantLock lock = new ReentrantLock(true);

    public static void doTask() {
        // 1. 加锁（可替换为 lockInterruptibly()：可中断锁）
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "获取锁");
            // 模拟业务操作
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢复中断状态
        } finally {
            // 2. 释放锁（必须放 finally，否则死锁）
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
                System.out.println(Thread.currentThread().getName() + "释放锁");
            }
        }
    }

    public static void main(String[] args) {
        new Thread(ReentrantLockDemo::doTask, "线程 A").start();
        new Thread(ReentrantLockDemo::doTask, "线程 B").start();
    }
}

二、进阶分类（按锁的核心特性）

基于锁的行为和并发特性分类，帮你理解锁的底层逻辑和适用场景。

1. 可重入锁 vs 不可重入锁

可重入锁示例（synchronized 递归调用）

public class ReentrantDemo {
    public synchronized void outer() {
        System.out.println("外层方法获取锁");
        inner(); // 同一线程再次获取同一锁，无死锁
    }

    public synchronized void inner() {
        System.out.println("内层方法获取锁");
    }

    public static void main(String[] args) {
        new ReentrantDemo().outer(); // 正常执行，无死锁
    }
}

2. 乐观锁 vs 悲观锁

这是并发设计思想的分类，而非具体锁实现。

乐观锁示例（CAS 实现）

import java.util.concurrent.atomic.AtomicInteger;

public class OptimisticLockDemo {
    // CAS 是乐观锁的核心实现
    private static final AtomicInteger count = new AtomicInteger(0);

    // 原子自增（无锁，冲突时重试）
    public static void increment() {
        count.incrementAndGet();
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) increment();
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("最终计数：" + count.get()); // 2000（线程安全）
    }
}

3. 公平锁 vs 非公平锁

4. 读写锁（ReentrantReadWriteLock）- 共享 + 独占锁

核心定义

将锁拆分为「读锁（共享锁）」和「写锁（独占锁）」，核心规则：

• 读 - 读共享：多个线程可同时获取读锁；
• 读 - 写互斥：读锁和写锁不能同时持有；
• 写 - 写互斥：多个线程不能同时获取写锁。

适用场景

读多写少的场景（如缓存、配置读取、商品详情页、数据查询），相比普通独占锁，能大幅提升读并发效率。

代码示例

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockDemo {
    private static final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private static final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private static final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
    private static int cacheData = 0;

    // 模拟缓存数据
    // 读操作（共享锁，多线程同时执行）
    public static void readCache() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "读取缓存：" + cacheData);
            Thread.sleep(200); // 模拟读耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            readLock.unlock();
        }
    }

    // 写操作（独占锁，串行执行）
    public static void updateCache(int newData) {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "更新缓存：" + newData);
            cacheData = newData;
            Thread.sleep(200); // 模拟写耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            writeLock.unlock();
        }
    }

    public static void main(String[] args) {
        // 5 个读线程（可同时执行，并发效率高）
        for (int i = 0; i < 5; i++) {
            new Thread(ReadWriteLockDemo::readCache, "读线程" + i).start();
        }
        // 1 个写线程（独占，所有读线程等待）
        new Thread(() -> updateCache(100), "写线程").start();
    }
}

5. synchronized 的锁升级（偏向锁→轻量级锁→重量级锁）

JDK1.6 为优化 synchronized 引入的自适应锁机制，锁级别从低到高升级（不可逆），适配不同并发场景：

6. 自旋锁 vs 阻塞锁

7. 分段锁（ConcurrentHashMap JDK1.7）

核心定义

将数据拆分为多个「段（Segment）」，每个段独立加锁，不同段的操作互不阻塞，并发度 = 段数（默认 16）。

适用场景

JDK1.7 的 ConcurrentHashMap（JDK1.8 后用 CAS+Synchronized 替代），适用于高并发读写 Map 的场景。

三、实战选型指南（核心）

总结

关键点回顾

1. 基础核心：synchronized（简单、通用）和 Lock 接口（灵活、高级）是 Java 锁的两大基石，前者适用于普通场景，后者适用于需要灵活控制的场景；
2. 特性选型：读多写少选读写锁，低冲突选乐观锁 / CAS，高冲突选悲观锁，公平性要求高选公平锁；
3. 性能原则：优先选择「开销低」的锁（如偏向锁、CAS），高冲突场景才用「高开销」的阻塞锁（如重量级锁）；
4. 实战建议：90% 的普通业务场景用 synchronized 即可，仅在需要可中断、超时、读写分离时才用 Lock 接口实现类。