Java多线程同步机制如何实现

Java多线程同步机制主要通过以下几种方式实现：

1. synchronized 关键字

synchronized 是Java中最基本的同步机制，它可以用来修饰方法或者以代码块的形式出现。

修饰方法

public synchronized void synchronizedMethod() {
    // 同步代码块
}

修饰代码块

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

2. ReentrantLock 类

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

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

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

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

3. ReadWriteLock 接口

ReadWriteLock 允许多个读线程同时访问，但写线程访问时需要独占锁。

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

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

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

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

4. Semaphore 类

Semaphore 是一个计数信号量，可以用来控制同时访问某一资源的线程数量。

import java.util.concurrent.Semaphore;

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

    public void performTask() {
        try {
            semaphore.acquire();
            // 同步代码块
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release();
        }
    }
}

5. CountDownLatch 类

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

import java.util.concurrent.CountDownLatch;

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

    public void performTask() {
        try {
            latch.await(); // 等待
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        // 同步代码块
    }

    public void completeTask() {
        latch.countDown(); // 减少计数
    }
}

6. CyclicBarrier 类

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

import java.util.concurrent.CyclicBarrier;

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

    public void performTask() {
        try {
            barrier.await(); // 等待其他线程
            // 同步代码块
        } catch (Exception e) {
            Thread.currentThread().interrupt();
        }
    }
}

总结

• synchronized：简单易用，适用于大多数同步场景。
• ReentrantLock：提供更灵活的锁定机制，支持公平锁、非公平锁、可中断锁等。
• ReadWriteLock：适用于读多写少的场景，提高并发性能。
• Semaphore：控制同时访问某一资源的线程数量。
• CountDownLatch：允许一个或多个线程等待其他线程完成操作。
• CyclicBarrier：允许一组线程互相等待，直到所有线程都到达一个屏障点。

选择合适的同步机制取决于具体的应用场景和需求。