当前位置：首页 > Java

Java如何上锁的

2026-03-18 07:30:31Java

Java 锁机制

Java 提供了多种锁机制，包括内置锁（synchronized）、显式锁（ReentrantLock）、读写锁（ReadWriteLock）等。以下是常见锁的使用方式。

内置锁（synchronized）

synchronized 是 Java 中最基本的锁机制，可以用于方法或代码块。

同步方法

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

同步代码块

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

显式锁（ReentrantLock）

ReentrantLock 是 java.util.concurrent.locks 包中的锁，提供了比 synchronized 更灵活的控制。

基本用法

Java如何上锁的

import java.util.concurrent.locks.ReentrantLock;

private final ReentrantLock lock = new ReentrantLock();

public void method() {
    lock.lock();
    try {
        // 同步代码
    } finally {
        lock.unlock();
    }
}

可中断锁

public void method() throws InterruptedException {
    lock.lockInterruptibly();
    try {
        // 同步代码
    } finally {
        lock.unlock();
    }
}

读写锁（ReadWriteLock）

ReadWriteLock 允许多个读线程同时访问，但写线程独占访问。

基本用法

Java如何上锁的

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

private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

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

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

锁的公平性

ReentrantLock 和 ReentrantReadWriteLock 支持公平锁模式，避免线程饥饿。

公平锁示例

private final ReentrantLock fairLock = new ReentrantLock(true);

public void method() {
    fairLock.lock();
    try {
        // 同步代码
    } finally {
        fairLock.unlock();
    }
}

条件变量（Condition）

Condition 允许线程在特定条件下等待或唤醒。

基本用法

private final ReentrantLock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();

public void waitMethod() throws InterruptedException {
    lock.lock();
    try {
        condition.await(); // 释放锁并等待
    } finally {
        lock.unlock();
    }
}

public void signalMethod() {
    lock.lock();
    try {
        condition.signal(); // 唤醒一个等待线程
    } finally {
        lock.unlock();
    }
}