Java如何实现多线程同步

在Java中，实现多线程同步主要有以下几种方式：

1. 使用synchronized关键字

synchronized关键字可以用来修饰方法或代码块，确保在同一时间只有一个线程可以执行被synchronized修饰的代码。

修饰方法

public synchronized void synchronizedMethod() {
    // 临界区代码
}

修饰代码块

public void someMethod() {
    synchronized (this) {
        // 临界区代码
    }
}

2. 使用ReentrantLock类

ReentrantLock类提供了比synchronized更灵活的锁定机制。

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

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

    public void someMethod() {
        lock.lock();
        try {
            // 临界区代码
        } finally {
            lock.unlock();
        }
    }
}

3. 使用ReadWriteLock接口

ReadWriteLock接口允许多个读线程同时访问，但写线程访问时会阻塞所有读线程和其他写线程。

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

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

    public void readMethod() {
        lock.readLock().lock();
        try {
            // 读操作
        } finally {
            lock.readLock().unlock();
        }
    }

    public void writeMethod() {
        lock.writeLock().lock();
        try {
            // 写操作
        } finally {
            lock.writeLock().unlock();
        }
    }
}

4. 使用Semaphore类

Semaphore类可以控制同时访问某一资源的线程数量。

import java.util.concurrent.Semaphore;

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

    public void someMethod() {
        try {
            semaphore.acquire();
            // 临界区代码
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release();
        }
    }
}

5. 使用CountDownLatch类

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

import java.util.concurrent.CountDownLatch;

public class Example {
    private final CountDownLatch latch = new CountDownLatch(3); // 等待3个线程完成

    public void someMethod() {
        try {
            latch.await(); // 等待
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public void completeTask() {
        latch.countDown(); // 完成一个任务
    }
}

6. 使用CyclicBarrier类

CyclicBarrier类允许一组线程互相等待，直到所有线程都到达一个屏障点。

import java.util.concurrent.CyclicBarrier;

public class Example {
    private final CyclicBarrier barrier = new CyclicBarrier(3); // 等待3个线程

    public void someMethod() {
        try {
            barrier.await(); // 等待其他线程
        } catch (Exception e) {
            Thread.currentThread().interrupt();
        }
    }
}

7. 使用ThreadLocal类

ThreadLocal类可以为每个线程提供独立的变量副本，从而避免线程间的数据竞争。

public class Example {
    private static final ThreadLocal<Integer> threadLocalValue = new ThreadLocal<>();

    public void someMethod() {
        threadLocalValue.set(10); // 设置当前线程的值
        int value = threadLocalValue.get(); // 获取当前线程的值
    }
}

选择合适的同步机制取决于具体的应用场景和需求。synchronized关键字简单易用，适用于大多数情况；ReentrantLock提供了更灵活的锁定机制；ReadWriteLock适用于读多写少的场景；Semaphore适用于控制并发访问数量；CountDownLatch和CyclicBarrier适用于线程间的协调；ThreadLocal适用于需要为每个线程提供独立变量的场景。