当前位置：首页 > Java

java如何线程同步

2026-03-03 05:26:10Java

线程同步的方法

Java中线程同步可以通过多种方式实现，以下是常用的几种方法：

synchronized关键字

使用synchronized修饰方法或代码块，确保同一时间只有一个线程可以访问共享资源。
示例代码：

public class Counter {
    private int count = 0;

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

ReentrantLock类

ReentrantLock提供了比synchronized更灵活的锁机制，支持公平锁和尝试获取锁。
示例代码：

import java.util.concurrent.locks.ReentrantLock;

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

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

volatile关键字

volatile确保变量的可见性，但不保证原子性。适用于单一变量的简单操作。
示例代码：

public class SharedObject {
    private volatile boolean flag = false;

    public void setFlag(boolean value) {
        flag = value;
    }
}

Atomic类

java.util.concurrent.atomic包下的类（如AtomicInteger）提供原子操作，无需加锁。
示例代码：

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

CyclicBarrier

CyclicBarrier让一组线程互相等待，达到某个屏障点后再继续执行。
示例代码：

import java.util.concurrent.CyclicBarrier;

public class Task implements Runnable {
    private final CyclicBarrier barrier;

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

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

Semaphore

Semaphore控制同时访问某个资源的线程数量。
示例代码：

import java.util.concurrent.Semaphore;

public class ResourcePool {
    private final Semaphore semaphore = new Semaphore(3);

    public void useResource() {
        semaphore.acquire();
        try {
            // 使用资源
        } finally {
            semaphore.release();
        }
    }
}