Java中实现互斥的四种方式

在Java中，实现互斥（即确保同一时间只有一个线程可以访问共享资源）可以通过以下几种方式：

1. 使用synchronized关键字

synchronized是Java中最基本的同步机制，可以用来修饰方法或代码块。用于保证同一时间只有一个线程可以访问被锁定的方法或代码块。

1.1同步方法

public class Counter {private int count = 0;public synchronized void increment() {count++;}public synchronized int getCount() {return count;}
}

1.2同步代码块

public class Counter {private int count = 0;private final Object lock = new Object();public void increment() {synchronized (lock) {count++;}}public int getCount() {synchronized (lock) {return count;}}
}

2. 使用ReentrantLock

ReentrantLock是java.util.concurrent.locks包中的一个类，是Java提供的一种可重入的互斥锁，它提供了更灵活的锁定机制，并且可以实现更复杂的同步需求。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class Counter {private int count = 0;private final Lock lock = new ReentrantLock();public void increment() {lock.lock();try {count++;} finally {lock.unlock();}}public int getCount() {lock.lock();try {return count;} finally {lock.unlock();}}
}

3. 使用Semaphore

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

import java.util.concurrent.Semaphore;public class Counter {private int count = 0;private final Semaphore semaphore = new Semaphore(1);public void increment() throws InterruptedException {semaphore.acquire();try {count++;} finally {semaphore.release();}}public int getCount() throws InterruptedException {semaphore.acquire();try {return count;} finally {semaphore.release();}}
}

4. 使用AtomicInteger

AtomicInteger是java.util.concurrent.atomic包中的一个类，提供了原子操作，可以用来实现无锁的线程安全。

import java.util.concurrent.atomic.AtomicInteger;public class Counter {private AtomicInteger count = new AtomicInteger(0);public void increment() {count.incrementAndGet();}public int getCount() {return count.get();}
}

5. 总结

• synchronized：简单易用，适用于大多数情况。
• ReentrantLock：更灵活，支持公平锁、非公平锁、可中断锁等特性。
• Semaphore：可以控制同时访问某一资源的线程数量。
• AtomicInteger：无锁的线程安全操作，性能较高。