Java中各类锁的类型、核心作用、适用场景示例代码详解

一、基础锁：内置锁（synchronized）

先从最基础的聊起。synchronized 是Ja va内置的隐式锁，在JVM层面实现。它最核心的几个特点：可重入性、默认非公平，以及最关键的一点——锁会自动释放，不管是方法执行完毕还是抛出异常，不需要开发者操心。

它的核心使命是保证多线程环境下的原子性、可见性和有序性，解决线程安全问题。简单说，就是确保一个线程修改了变量，其他线程能立刻看到，并且操作不会被拆得支离破碎。

适用场景也很明确：简单的线程安全场景，比如单例模式、共享变量修改。开发成本低，不需要手动释放锁，对新手特别友好，或者说是快速实现同步的首选方案。

看看具体怎么用，有三种方式：

public class SynchronizedLockDemo {
    // 1. 修饰实例方法（锁对象是当前类的实例）
    public synchronized void instanceMethodLock() {
        System.out.println("实例方法锁：" + Thread.currentThread().getName());
        try {
            Thread.sleep(1000); // 模拟业务操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    // 2. 修饰静态方法（锁对象是当前类的Class对象）
    public static synchronized void staticMethodLock() {
        System.out.println("静态方法锁：" + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    // 3. 修饰代码块（手动指定锁对象，灵活性更高）
    public void codeBlockLock() {
        // 锁对象可以是任意非null对象，常用this（实例锁）或类对象（全局锁）
        synchronized (this) {
            System.out.println("代码块锁（实例）：" + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    public static void main(String[] args) {
        SynchronizedLockDemo demo = new SynchronizedLockDemo();
        // 测试实例方法锁（多线程竞争同一个实例锁）
        new Thread(demo::instanceMethodLock, "线程1").start();
        new Thread(demo::instanceMethodLock, "线程2").start();
        // 测试静态方法锁（多线程竞争类锁）
        new Thread(SynchronizedLockDemo::staticMethodLock, "线程3").start();
        new Thread(SynchronizedLockDemo::staticMethodLock, "线程4").start();
        // 测试代码块锁
        new Thread(demo::codeBlockLock, "线程5").start();
        new Thread(demo::codeBlockLock, "线程6").start();
    }
}

代码解释

• 实例方法锁：锁的是 demo 这个实例，所以线程1和线程2会串行执行。
• 静态方法锁：锁的是 SynchronizedLockDemo.class，线程3和线程4同样串行执行。
• 代码块锁：锁对象由你指定，灵活性更高——可以只锁关键代码，而不是整个方法，粒度可控。

二、显式锁：ReentrantLock（可重入锁）

如果说 synchronized 是自动挡，那 ReentrantLock 就是手动挡。它实现了 Lock 接口，是典型的显式锁——需要手动加锁和释放锁。支持可重入性，可以配置公平锁或非公平锁，还提供了中断、超时获取、尝试获取等高级特性。

它的核心价值在于比 synchronized 更灵活，解决了后者无法中断、无法设置超时、无法尝试获取锁的问题，适合复杂的同步场景。

什么时候该用它？

• 需要公平锁，即按线程等待顺序获取锁的场景。
• 需要超时等待锁，避免线程永久阻塞。
• 需要可中断的锁获取，比如优雅停止线程。
• 需要尝试获取锁，获取不到就执行其他逻辑，不干等。

看代码：

import ja va.util.concurrent.locks.ReentrantLock;
public class ReentrantLockDemo {
    // 1. 创建ReentrantLock：参数true为公平锁，false（默认）为非公平锁
    private static final ReentrantLock FAIR_LOCK = new ReentrantLock(true);
    private static final ReentrantLock NON_FAIR_LOCK = new ReentrantLock(false);
    // 演示公平锁（按等待顺序获取锁）
    public static void fairLockDemo() {
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                FAIR_LOCK.lock(); // 手动加锁
                try {
                    System.out.println("公平锁获取成功：" + Thread.currentThread().getName());
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    FAIR_LOCK.unlock(); // 必须在finally中释放锁，避免死锁
                }
            }, "公平锁线程-" + i).start();
        }
    }
    // 演示尝试获取锁（非阻塞）
    public static void tryLockDemo() {
        Thread thread1 = new Thread(() -> {
            NON_FAIR_LOCK.lock();
            try {
                System.out.println("线程1持有锁，执行10秒");
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                NON_FAIR_LOCK.unlock();
            }
        });
        Thread thread2 = new Thread(() -> {
            boolean isLockAcquired = NON_FAIR_LOCK.tryLock(); // 尝试获取锁，立即返回结果
            if (isLockAcquired) {
                try {
                    System.out.println("线程2获取锁成功");
                } finally {
                    NON_FAIR_LOCK.unlock();
                }
            } else {
                System.out.println("线程2获取锁失败，执行备用逻辑");
            }
        });
        thread1.start();
        Thread.sleep(1000); // 确保线程1先获取锁
        thread2.start();
    }
    // 演示超时获取锁（避免永久阻塞）
    public static void tryLockWithTimeoutDemo() throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            NON_FAIR_LOCK.lock();
            try {
                System.out.println("线程1持有锁，执行3秒");
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                NON_FAIR_LOCK.unlock();
            }
        });
        Thread thread2 = new Thread(() -> {
            try {
                // 尝试获取锁，最多等待5秒，超时返回false
                boolean isLockAcquired = NON_FAIR_LOCK.tryLock(5, ja va.util.concurrent.TimeUnit.SECONDS);
                if (isLockAcquired) {
                    try {
                        System.out.println("线程2超时等待后获取锁成功");
                    } finally {
                        NON_FAIR_LOCK.unlock();
                    }
                } else {
                    System.out.println("线程2超时等待5秒后仍未获取锁");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("线程2获取锁时被中断");
            }
        });
        thread1.start();
        Thread.sleep(100); // 确保线程1先获取锁
        thread2.start();
    }
    public static void main(String[] args) throws InterruptedException {
        System.out.println("===== 公平锁演示 =====");
        fairLockDemo();
        Thread.sleep(3000); // 等待公平锁演示完成
        System.out.println("n===== 尝试获取锁演示 =====");
        tryLockDemo();
        Thread.sleep(11000); // 等待尝试获取锁演示完成
        System.out.println("n===== 超时获取锁演示 =====");
        tryLockWithTimeoutDemo();
    }
}

代码解释

• 公平锁：线程按等待顺序获取锁，避免“饥饿”，也就是防止某个线程一直抢不到锁。
• tryLock()：非阻塞获取锁，获取不到直接走备用逻辑，不耽误事。
• tryLock(time, unit)：超时等待锁，超时后放弃，避免线程永久阻塞。
• 必须把 unlock() 放在 finally 块里，这是铁律，否则锁不会自动释放，很容易死锁。

三、读写锁：ReentrantReadWriteLock

想象一下这样的场景：一个系统里，读操作占了90%，写操作只有10%。如果用 synchronized 或 ReentrantLock，那所有读操作也被迫串行执行，性能损失很大。读写锁就是为解决这个问题而生的。

它基于 Lock 接口，分为读锁（共享锁）和写锁（独占锁）。规则很简单：读-读共享，多个线程可以同时拿读锁；但读-写、写-读、写-写之间是互斥的，写操作必须独占。

什么时候用？

• 缓存系统，比如本地缓存、Redis客户端缓存。
• 配置中心，高频读取配置，低频修改配置。
• 数据查询系统，多线程读，少线程更新。

看代码实现：

import ja va.util.HashMap;
import ja va.util.Map;
import ja va.util.concurrent.locks.ReentrantReadWriteLock;
/**
 * 读写锁演示：模拟缓存系统（读多写少）
 */
public class ReadWriteLockDemo {
    // 缓存容器
    private static final Map CACHE = new HashMap<>();
    // 读写锁
    private static final ReentrantReadWriteLock RW_LOCK = new ReentrantReadWriteLock();
    // 读锁
    private static final ReentrantReadWriteLock.ReadLock READ_LOCK = RW_LOCK.readLock();
    // 写锁
    private static final ReentrantReadWriteLock.WriteLock WRITE_LOCK = RW_LOCK.writeLock();
    // 从缓存读取数据（读操作，加读锁）
    public static String get(String key) {
        READ_LOCK.lock(); // 加读锁
        try {
            System.out.println(Thread.currentThread().getName() + " 读取缓存：" + key);
            Thread.sleep(500); // 模拟读操作耗时
            return CACHE.get(key);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        } finally {
            READ_LOCK.unlock(); // 释放读锁
        }
    }
    // 向缓存写入数据（写操作，加写锁）
    public static void put(String key, String value) {
        WRITE_LOCK.lock(); // 加写锁
        try {
            System.out.println(Thread.currentThread().getName() + " 写入缓存：" + key + "=" + value);
            Thread.sleep(1000); // 模拟写操作耗时
            CACHE.put(key, value);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            WRITE_LOCK.unlock(); // 释放写锁
        }
    }
    public static void main(String[] args) {
        // 1. 模拟多线程读缓存（读锁共享，并行执行）
        for (int i = 0; i < 5; i++) {
            new Thread(() -> get("user:1001"), "读线程-" + i).start();
        }
        // 2. 模拟写缓存（写锁独占，串行执行）
        new Thread(() -> put("user:1001", "张三"), "写线程-1").start();
        new Thread(() -> put("user:1002", "李四"), "写线程-2").start();
        // 3. 模拟读-写互斥（读线程等待写线程释放锁）
        new Thread(() -> get("user:1002"), "读线程-5").start();
    }
}

代码解释

• 读线程1到5会并行执行，输出几乎同时出现——因为读锁是共享的。
• 写线程1和写线程2串行执行，写锁必须独占。
• 读线程5会等到写线程2释放锁之后才执行，体现了读-写互斥。
• 读写锁的核心价值就在这里：读多写少时，读操作并行，大幅提升并发性能。

四、设计思想：乐观锁 vs 悲观锁

这里谈的不是具体的锁实现，而是两种设计思想。Ja va中很多锁都是基于这两种思想构建的。

1. 悲观锁

核心特点：认为每次操作都可能有线程竞争，所以“先加锁，再操作”，确保操作过程中没有其他线程干扰。

作用：解决高竞争场景下的线程安全问题，用性能换取安全。

使用场景：线程竞争激烈、写操作频繁的场景，比如库存扣减、转账。

示例代码（synchronized实现悲观锁）

public class PessimisticLockDemo {
    private int count = 0;
    // 悲观锁：先加锁再操作
    public synchronized void increment() {
        count++;
        System.out.println(Thread.currentThread().getName() + " 执行自增，count=" + count);
    }
    public static void main(String[] args) {
        PessimisticLockDemo demo = new PessimisticLockDemo();
        for (int i = 0; i < 10; i++) {
            new Thread(demo::increment, "线程-" + i).start();
        }
    }
}

2. 乐观锁

核心特点：认为每次操作都没有竞争，所以不加锁，只在更新时通过CAS（Compare And Swap）检查数据是否被修改。如果没被改，直接更新；如果被改了，重试或放弃。

作用：无锁竞争时性能极高，牺牲少量安全性（极端情况可能遇到ABA问题）来换取性能。

使用场景：线程竞争小、读多写少的场景，比如计数器、库存扣减优化。

示例代码（AtomicInteger实现CAS乐观锁）

import ja va.util.concurrent.atomic.AtomicInteger;
public class OptimisticLockDemo {
    // AtomicInteger底层通过CAS实现乐观锁
    private static final AtomicInteger COUNT = new AtomicInteger(0);
    // 乐观锁：无锁操作，CAS更新
    public static void increment() {
        // CAS自增：预期值为当前值，更新为当前值+1，失败则重试
        int oldValue;
        int newValue;
        do {
            oldValue = COUNT.get(); // 获取当前值
            newValue = oldValue + 1; // 计算新值
            // CAS尝试更新：如果当前值还是oldValue，就更新为newValue，返回true；否则返回false
        } while (!COUNT.compareAndSet(oldValue, newValue));
        System.out.println(Thread.currentThread().getName() + " 执行自增，count=" + newValue);
    }
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(OptimisticLockDemo::increment, "线程-" + i).start();
        }
    }
}

代码解释

• compareAndSet(oldValue, newValue) 是核心CAS方法，保证原子性。
• 循环重试：如果CAS失败，说明其他线程已经修改了值，那就重新获取当前值，再试一次。
• 无锁竞争时，CAS一次成功，性能远高于悲观锁。

五、进阶锁：StampedLock（Ja va8新增）

这是读写锁的增强版，支持三种模式：

• 写锁：独占锁，和 ReentrantReadWriteLock 的写锁一致。
• 悲观读锁：共享锁，和 ReentrantReadWriteLock 的读锁一致。
• 乐观读锁：无锁模式，仅检查版本号，不加锁，性能比悲观读锁更高。

核心价值：优化“读极多、写极少”的场景，乐观读模式下无锁竞争，性能远超 ReentrantReadWriteLock。

使用场景：超高并发的读场景，比如高频访问的商品详情、用户信息。

看代码：

import ja va.util.concurrent.locks.StampedLock;
public class StampedLockDemo {
    private double x = 0.0, y = 0.0;
    private final StampedLock stampedLock = new StampedLock();
    // 写操作：获取写锁
    public void move(double deltaX, double deltaY) {
        long stamp = stampedLock.writeLock(); // 获取写锁，返回版本戳
        try {
            x += deltaX;
            y += deltaY;
            System.out.println("写操作：x=" + x + ", y=" + y);
        } finally {
            stampedLock.unlockWrite(stamp); // 释放写锁
        }
    }
    // 乐观读操作：无锁，仅检查版本戳
    public double distanceFromOrigin() {
        long stamp = stampedLock.tryOptimisticRead(); // 获取乐观读戳
        double currentX = x, currentY = y; // 读取数据
        // 检查乐观读期间是否有写操作（版本戳是否有效）
        if (!stampedLock.validate(stamp)) {
            // 有写操作，升级为悲观读锁
            stamp = stampedLock.readLock();
            try {
                currentX = x;
                currentY = y;
            } finally {
                stampedLock.unlockRead(stamp); // 释放悲观读锁
            }
        }
        // 计算距离
        double distance = Math.sqrt(currentX * currentX + currentY * currentY);
        System.out.println("乐观读操作：距离=" + distance);
        return distance;
    }
    public static void main(String[] args) throws InterruptedException {
        StampedLockDemo demo = new StampedLockDemo();
        // 模拟多线程乐观读
        for (int i = 0; i < 5; i++) {
            new Thread(demo::distanceFromOrigin, "乐观读线程-" + i).start();
        }
        // 模拟写操作
        Thread.sleep(100);
        new Thread(() -> demo.move(1.0, 2.0), "写线程").start();
        // 再次模拟乐观读
        Thread.sleep(100);
        new Thread(demo::distanceFromOrigin, "乐观读线程-5").start();
    }
}

代码解释

• 乐观读：无锁读取数据，只通过版本戳验证是否有写操作，性能极高。
• 如果版本戳失效，就升级为悲观读锁，保证数据一致性。
• 写锁是独占的，修改数据时会阻塞所有读和写操作。

六、其他常见锁

总结

1. 基础场景选 synchronized：JVM内置锁，简单易用，自动释放，适合新手或简单同步场景。
2. 复杂场景选 ReentrantLock：支持公平锁、超时、中断、尝试获取锁，灵活性更高。
3. 读多写少选读写锁：ReentrantReadWriteLock（基础版）或 StampedLock（高性能版），读操作并行提升并发能力。
4. 低竞争选乐观锁（CAS）：通过 Atomic 系列类实现，无锁操作，性能远高于悲观锁；高竞争则选悲观锁（synchronized / ReentrantLock）。

核心原则其实就一句话：根据竞争程度选择锁——竞争小用乐观锁、轻量级锁，竞争大用悲观锁、重量级锁；读多写少用读写锁，写多读少用独占锁。