当前位置：首页 > Java

java如何实现多线程同步

2026-03-17 18:25:32Java

Java 多线程同步的实现方法

Java 提供了多种机制来实现多线程同步，确保线程安全。以下是常见的实现方式：

synchronized 关键字

synchronized 可以修饰方法或代码块，确保同一时间只有一个线程可以访问被保护的资源。

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

ReentrantLock

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

java如何实现多线程同步

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

volatile 关键字

volatile 确保变量的可见性，但不保证原子性。适用于简单的状态标志。

public class VolatileExample {
    private volatile boolean flag = false;

    public void toggleFlag() {
        flag = !flag;
    }
}

Atomic 类

java.util.concurrent.atomic 包提供了原子类（如 AtomicInteger），适合计数器等场景。

java如何实现多线程同步

import java.util.concurrent.atomic.AtomicInteger;

public class Counter {
    private AtomicInteger count = new AtomicInteger(0);

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

CountDownLatch

CountDownLatch 允许一个或多个线程等待其他线程完成操作。

import java.util.concurrent.CountDownLatch;

public class Worker implements Runnable {
    private final CountDownLatch latch;

    public Worker(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void run() {
        // 执行任务
        latch.countDown();
    }
}

Semaphore

Semaphore 控制同时访问特定资源的线程数量。

import java.util.concurrent.Semaphore;

public class ResourcePool {
    private Semaphore semaphore = new Semaphore(3); // 允许3个线程同时访问

    public void accessResource() {
        try {
            semaphore.acquire();
            // 访问资源
        } finally {
            semaphore.release();
        }
    }
}

CyclicBarrier

CyclicBarrier 让一组线程互相等待，到达屏障点后再继续执行。

import java.util.concurrent.CyclicBarrier;

public class Task implements Runnable {
    private CyclicBarrier barrier;

    public Task(CyclicBarrier barrier) {
        this.barrier = barrier;
    }

    @Override
    public void run() {
        // 执行任务
        barrier.await(); // 等待其他线程
    }
}