当前位置：首页 > Java

java线程如何加锁

2026-03-20 22:37:10Java

使用 synchronized 关键字

synchronized 是 Java 中最基础的锁机制，可以修饰方法或代码块。修饰方法时，锁对象是当前实例（非静态方法）或类对象（静态方法）；修饰代码块时，需显式指定锁对象。

修饰方法：

public synchronized void method() {
    // 同步代码
}

修饰代码块：

public void method() {
    synchronized (this) {  // 锁对象为当前实例
        // 同步代码
    }
}

使用 ReentrantLock

ReentrantLock 是 java.util.concurrent.locks 包下的显式锁，提供比 synchronized 更灵活的锁控制，支持公平锁、可中断锁等特性。

基本用法：

java线程如何加锁

private final ReentrantLock lock = new ReentrantLock();

public void method() {
    lock.lock();  // 加锁
    try {
        // 同步代码
    } finally {
        lock.unlock();  // 确保锁释放
    }
}

公平锁模式：

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

使用 ReadWriteLock

ReadWriteLock 通过分离读锁和写锁提高并发性能，适合读多写少的场景。

实现类 ReentrantReadWriteLock：

java线程如何加锁

private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

public void readData() {
    rwLock.readLock().lock();  // 加读锁
    try {
        // 读操作
    } finally {
        rwLock.readLock().unlock();
    }
}

public void writeData() {
    rwLock.writeLock().lock();  // 加写锁
    try {
        // 写操作
    } finally {
        rwLock.writeLock().unlock();
    }
}

使用 StampedLock

StampedLock 是 Java 8 引入的乐观读锁机制，适合读操作远多于写操作的场景，性能优于 ReadWriteLock。

乐观读示例：

private final StampedLock stampedLock = new StampedLock();

public double read() {
    long stamp = stampedLock.tryOptimisticRead();  // 获取乐观读戳
    double value = sharedValue;  // 读取共享数据
    if (!stampedLock.validate(stamp)) {  // 检查是否被写操作修改
        stamp = stampedLock.readLock();  // 升级为悲观读锁
        try {
            value = sharedValue;
        } finally {
            stampedLock.unlockRead(stamp);
        }
    }
    return value;
}

写锁示例：

public void write(double newValue) {
    long stamp = stampedLock.writeLock();
    try {
        sharedValue = newValue;
    } finally {
        stampedLock.unlockWrite(stamp);
    }
}