当前位置：首页 > Java

如何同步 java

2026-03-20 08:42:02Java

同步 Java 的方法

使用 `synchronized` 关键字

synchronized 可以修饰方法或代码块，确保同一时间只有一个线程访问共享资源。修饰方法时，锁对象是当前实例（非静态方法）或类对象（静态方法）。

public synchronized void synchronizedMethod() {
    // 同步方法
}

修饰代码块时，需明确指定锁对象。

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

使用 `ReentrantLock`

ReentrantLock 是显式锁，提供比 synchronized 更灵活的锁定机制，支持公平锁、可中断锁等特性。

private final ReentrantLock lock = new ReentrantLock();

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

使用 `volatile` 关键字

volatile 确保变量的可见性，但不保证原子性。适用于单个变量的简单同步场景。

如何同步 java

private volatile int counter;

使用原子类（`AtomicInteger` 等）

java.util.concurrent.atomic 包提供原子类（如 AtomicInteger），通过 CAS 操作保证原子性，适合计数器等场景。

private AtomicInteger counter = new AtomicInteger(0);

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

使用 `CountDownLatch` 或 `CyclicBarrier`

CountDownLatch 和 CyclicBarrier 用于协调多个线程的执行顺序。CountDownLatch 是一次性的，CyclicBarrier 可重复使用。

如何同步 java

CountDownLatch latch = new CountDownLatch(3);

// 线程中调用
latch.countDown();
latch.await(); // 等待其他线程完成

使用 `Semaphore`

Semaphore 控制同时访问资源的线程数量，适用于限流场景。

Semaphore semaphore = new Semaphore(3);

public void method() throws InterruptedException {
    semaphore.acquire();
    try {
        // 受限资源访问
    } finally {
        semaphore.release();
    }
}

使用线程安全的集合类

ConcurrentHashMap、CopyOnWriteArrayList 等线程安全集合类，适用于高并发场景。

Map<String, String> map = new ConcurrentHashMap<>();
map.put("key", "value");

使用 `ThreadLocal`

ThreadLocal 为每个线程提供独立的变量副本，避免共享变量的问题。

private ThreadLocal<Integer> threadLocalCounter = ThreadLocal.withInitial(() -> 0);

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