当前位置：首页 > Java

java如何加锁

2026-03-19 20:51:56Java

加锁的基本方法

在Java中，加锁可以通过synchronized关键字或java.util.concurrent.locks包中的锁工具实现。synchronized是最基础的加锁方式，可以直接修饰方法或代码块。

// 修饰方法
public synchronized void method() {
    // 同步代码
}

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

使用Lock接口

java.util.concurrent.locks.Lock接口提供了更灵活的加锁机制，例如ReentrantLock。与synchronized相比，它支持公平锁、可中断锁和超时锁。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

private final Lock lock = new ReentrantLock();

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

读写锁

ReadWriteLock接口及其实现类ReentrantReadWriteLock适用于读多写少的场景。读写锁允许多个线程同时读取，但写入时独占。

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();
    }
}

条件变量

Condition接口可以与Lock配合使用，实现线程间的协调。例如，生产者-消费者模型中可以通过条件变量实现等待和唤醒。

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

public void await() throws InterruptedException {
    lock.lock();
    try {
        condition.await();
    } finally {
        lock.unlock();
    }
}

public void signal() {
    lock.lock();
    try {
        condition.signal();
    } finally {
        lock.unlock();
    }
}

原子类

对于简单的原子操作，可以使用java.util.concurrent.atomic包中的原子类，如AtomicInteger。这些类通过CAS（Compare-And-Swap）实现无锁线程安全。

java如何加锁

import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger counter = new AtomicInteger(0);

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