当前位置：首页 > Java

java如何上锁

2026-03-19 21:02:11Java

Java 中的锁机制

Java 提供了多种锁机制来控制多线程并发访问共享资源，确保线程安全。以下是常见的锁实现方式：

使用 `synchronized` 关键字

synchronized 是 Java 中最基础的锁机制，可以修饰方法或代码块：

java如何上锁

// 修饰实例方法
public synchronized void method() {
    // 临界区代码
}

// 修饰静态方法
public static synchronized void staticMethod() {
    // 临界区代码
}

// 修饰代码块（指定锁对象）
public void block() {
    synchronized (this) {  // 锁对象可以是任意对象
        // 临界区代码
    }
}

使用 `ReentrantLock`

ReentrantLock 是 java.util.concurrent.locks 包提供的显式锁，比 synchronized 更灵活：

import java.util.concurrent.locks.ReentrantLock;

private final ReentrantLock lock = new ReentrantLock();

public void lockMethod() {
    lock.lock();  // 获取锁
    try {
        // 临界区代码
    } finally {
        lock.unlock();  // 必须在 finally 中释放锁
    }
}

使用 `ReadWriteLock`

ReadWriteLock 支持读写分离，适用于读多写少的场景：

java如何上锁

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

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 引入的乐观读锁，性能更高：

import java.util.concurrent.locks.StampedLock;

private final StampedLock stampedLock = new StampedLock();

public void optimisticRead() {
    long stamp = stampedLock.tryOptimisticRead();
    // 读操作
    if (!stampedLock.validate(stamp)) {
        stamp = stampedLock.readLock();
        try {
            // 重新读操作
        } finally {
            stampedLock.unlockRead(stamp);
        }
    }
}

public void write() {
    long stamp = stampedLock.writeLock();
    try {
        // 写操作
    } finally {
        stampedLock.unlockWrite(stamp);
    }
}

使用 `Lock` 接口的其他实现

Java 还提供了其他锁实现，如 Semaphore、CountDownLatch 等，适用于特定场景：

import java.util.concurrent.Semaphore;

private final Semaphore semaphore = new Semaphore(1);  // 允许1个线程访问

public void semaphoreMethod() throws InterruptedException {
    semaphore.acquire();
    try {
        // 临界区代码
    } finally {
        semaphore.release();
    }
}