当前位置：首页 > Java

java如何实现同步

2026-04-09 07:00:28Java

Java 实现同步的方法

Java 提供了多种机制来实现同步，确保多线程环境下的线程安全和数据一致性。以下是几种常见的同步实现方式：

synchronized 关键字

synchronized 是 Java 中最基本的同步机制，可以用于方法或代码块。当一个线程进入 synchronized 方法或代码块时，其他线程必须等待。

同步方法：

public synchronized void synchronizedMethod() {
    // 线程安全的代码
}

同步代码块：

public void someMethod() {
    synchronized(this) {
        // 线程安全的代码
    }
}

ReentrantLock 类

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

import java.util.concurrent.locks.ReentrantLock;

public class Example {
    private final ReentrantLock lock = new ReentrantLock();

    public void performTask() {
        lock.lock();
        try {
            // 线程安全的代码
        } finally {
            lock.unlock();
        }
    }
}

volatile 关键字

volatile 关键字用于修饰变量，确保变量的可见性。当一个线程修改了 volatile 变量的值，其他线程能立即看到修改后的值。

public class Example {
    private volatile boolean flag = false;

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

    public boolean getFlag() {
        return flag;
    }
}

原子类（Atomic Classes）

Java 提供了一系列原子类（如 AtomicInteger、AtomicLong 等），用于在多线程环境下进行原子操作。

import java.util.concurrent.atomic.AtomicInteger;

public class Example {
    private AtomicInteger counter = new AtomicInteger(0);

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

    public int getValue() {
        return counter.get();
    }
}

并发集合（Concurrent Collections）

Java 的 java.util.concurrent 包提供了线程安全的集合类，如 ConcurrentHashMap、CopyOnWriteArrayList 等。

import java.util.concurrent.ConcurrentHashMap;

public class Example {
    private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

    public void addToMap(String key, Integer value) {
        map.put(key, value);
    }

    public Integer getFromMap(String key) {
        return map.get(key);
    }
}

CountDownLatch 和 CyclicBarrier

CountDownLatch 和 CyclicBarrier 是用于协调多个线程的工具类。

CountDownLatch：

import java.util.concurrent.CountDownLatch;

public class Example {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                // 执行任务
                latch.countDown();
            }).start();
        }

        latch.await(); // 等待所有线程完成任务
    }
}

CyclicBarrier：

java如何实现同步

import java.util.concurrent.CyclicBarrier;

public class Example {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(3, () -> {
            // 所有线程到达屏障后执行的任务
        });

        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                try {
                    // 执行任务
                    barrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}