Java多线程：同步机制详解

Java多线程中的同步机制是确保多个线程在访问共享资源时，能够按照一定的顺序执行，避免数据不一致的问题。Java提供了多种同步机制，主要包括以下几种：

1. synchronized关键字

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

修饰方法

当synchronized修饰一个实例方法时，锁的是调用该方法的实例对象。

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

当synchronized修饰一个静态方法时，锁的是类的Class对象。

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

同步代码块

synchronized也可以用来修饰代码块，这样可以更细粒度地控制锁的范围。

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 someMethod() {
        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 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 SemaphoreExample {
    private final Semaphore semaphore = new Semaphore(5); // 允许5个线程同时访问

    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 CountDownLatchExample {
    private final CountDownLatch latch = new CountDownLatch(3); // 等待3个线程完成

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

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

6. CyclicBarrier类

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

import java.util.concurrent.CyclicBarrier;

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

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

总结

Java多线程中的同步机制多种多样，选择合适的同步机制可以提高程序的性能和可靠性。synchronized关键字是最基本的同步机制，适用于大多数场景。ReentrantLock提供了更灵活的锁定机制，ReadWriteLock适用于读多写少的场景，Semaphore可以控制同时访问某一资源的线程数量，CountDownLatch和CyclicBarrier则用于线程间的协调工作。