Java中多线程如何实现同步

在Java中，多线程同步可以通过以下几种方式实现：

1. 使用synchronized关键字：
   • 同步方法：在方法声明前加上synchronized关键字，这样该方法成为同步方法，同一时刻只有一个线程可以执行该方法。
   • 同步代码块：在代码块前加上synchronized关键字，并指定一个锁对象，这样只有获得锁对象的线程才能执行该代码块。

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

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

2. 使用ReentrantLock类： ReentrantLock是java.util.concurrent.locks包下的一个类，它提供了比synchronized更灵活的锁定机制。

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

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

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

3. 使用Semaphore类： Semaphore是java.util.concurrent.Semaphore包下的一个类，它提供了信号量机制，可以控制同时访问某一资源的线程数量。

import java.util.concurrent.Semaphore;

public class MyClass {
    private final Semaphore semaphore = new Semaphore(1);

    public void semaphoreMethod() {
        try {
            semaphore.acquire();
            // 同步代码块体
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
        }
    }
}

4. 使用CountDownLatch类： CountDownLatch是java.util.concurrent.CountDownLatch包下的一个类，它允许一个或多个线程等待其他线程完成操作。

import java.util.concurrent.CountDownLatch;

public class MyClass {
    private final CountDownLatch latch = new CountDownLatch(1);

    public void countDownLatchMethod() {
        try {
            latch.await();
            // 同步代码块体
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void countDownLatchCountDown() {
        latch.countDown();
    }
}

5. 使用CyclicBarrier类： CyclicBarrier是java.util.concurrent.CyclicBarrier包下的一个类，它允许一组线程互相等待，直到所有线程都准备好继续执行。

import java.util.concurrent.CyclicBarrier;

public class MyClass {
    private final CyclicBarrier barrier = new CyclicBarrier(2);

    public void cyclicBarrierMethod() {
        try {
            barrier.await();
            // 同步代码块体
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这些方法都可以实现多线程同步，具体选择哪种方法取决于你的需求和应用场景。