当前位置：首页 > news >正文

Java 锁机制全面解析

news 来源：原创 2025/5/3 3:03:51

在 Java 并发编程中，锁（Lock）是保证线程安全的关键工具。本文将全面介绍 Java 的锁机制，包括 synchronized 关键字、Lock 接口及其实现、读写锁、乐观锁与悲观锁等，帮助新手理解 Java 并发控制。

1. Java 中的锁概述

锁（Lock）用于控制多个线程对共享资源的访问。不同的锁机制可以提供不同的性能、可重入性、公平性和可中断性等特性。

2. `synchronized` 关键字

synchronized 是 Java 内置的同步机制，依赖于 Java 虚拟机（JVM）实现。

2.1 用法示例

public class SynchronizedExample {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
}

在上述示例中，increment 方法是同步方法，多个线程调用时会自动加锁，保证 count 变量的线程安全。

2.2 `synchronized` 作用范围

同步实例方法：锁住当前实例（this）。
同步静态方法：锁住类对象（Class）。
同步代码块：可以锁定特定对象，提高并发性。

public void method() {
    synchronized (this) {
        // 代码块
    }
}

2.3 `synchronized` 的特性

可重入性：一个线程获取锁后可以多次进入同步代码。
不可中断：线程获取锁后，其他线程只能等待。
JVM 层面实现：使用 monitorenter 和 monitorexit 指令。

3. `Lock` 接口（显式锁）

Lock 接口提供比 synchronized 更灵活的锁控制，主要实现类是 ReentrantLock。

3.1 `ReentrantLock` 用法

import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private final ReentrantLock lock = new ReentrantLock();
    private int count = 0;

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

3.2 `ReentrantLock` 特性

可重入性：和 synchronized 类似，一个线程可以多次获得相同的锁。
可中断：支持 lockInterruptibly() 方法，中断等待锁的线程。
公平锁和非公平锁：默认非公平锁，可选择公平锁保证线程按请求顺序获取锁。

ReentrantLock fairLock = new ReentrantLock(true); // 公平锁

4. `ReadWriteLock`（读写锁）

ReadWriteLock 提供读锁（多个线程可读）和写锁（独占）。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private int data = 0;

    public int read() {
        lock.readLock().lock();
        try {
            return data;
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write(int value) {
        lock.writeLock().lock();
        try {
            data = value;
        } finally {
            lock.writeLock().unlock();
        }
    }
}

5. 乐观锁与悲观锁

5.1 悲观锁

认为竞争严重，每次访问资源都加锁（synchronized、Lock）。

5.2 乐观锁

认为竞争较少，使用 CAS（Compare And Swap） 机制，比如 AtomicInteger。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private final AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }
}

6. `StampedLock`（改进的读写锁）

StampedLock 提供乐观读锁，提高并发性能。

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private final StampedLock lock = new StampedLock();
    private int data = 0;

    public int read() {
        long stamp = lock.tryOptimisticRead();
        int currentData = data;
        if (!lock.validate(stamp)) { // 检测数据是否被修改
            lock.readLock();
            try {
                currentData = data;
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return currentData;
    }
}

7. `ThreadLocal` 变量

ThreadLocal 不是锁，而是让每个线程拥有自己的变量副本，避免锁竞争。

public class ThreadLocalExample {
    private static final ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public void increment() {
        threadLocal.set(threadLocal.get() + 1);
    }
}

8. 选择合适的锁

锁类型	特性	适用场景
`synchronized`	JVM 层面，简单易用	适合简单同步需求
`ReentrantLock`	可中断、支持公平锁	适合需要高级控制的场景
`ReadWriteLock`	读写分离，提高并发	读多写少的情况
`StampedLock`	乐观读，提高性能	适合高并发读的场景
`ThreadLocal`	线程私有，无锁	线程隔离数据