Java如何限制并发
限制并发的方法
在Java中，可以通过多种方式限制并发访问，确保系统资源合理分配并避免过载。以下是几种常见的方法：
使用Semaphore（信号量）
Semaphore是一种计数器，用于控制同时访问某个资源的线程数量。通过初始化信号量时指定许可数，可以实现并发限制。
import java.util.concurrent.Semaphore;
public class SemaphoreExample {
private static final int MAX_CONCURRENT_THREADS = 5;
private static final Semaphore semaphore = new Semaphore(MAX_CONCURRENT_THREADS);
public void limitedTask() {
try {
semaphore.acquire();
// 执行并发受限的任务
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
semaphore.release();
}
}
}使用ThreadPoolExecutor（线程池）
通过固定线程池的大小，可以限制并发线程的数量。线程池会管理线程的生命周期和任务队列。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
private static final int MAX_THREADS = 5;
private static final ExecutorService executor = Executors.newFixedThreadPool(MAX_THREADS);
public void submitTask(Runnable task) {
executor.submit(task);
}
}使用CountDownLatch（倒计时门闩）
CountDownLatch可以阻塞线程直到计数器归零，适合控制多个线程同时开始或结束。
import java.util.concurrent.CountDownLatch;
public class CountDownLatchExample {
private static final int THREAD_COUNT = 5;
private static final CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
public void awaitTasks() throws InterruptedException {
latch.await(); // 阻塞直到计数器归零
}
public void completeTask() {
latch.countDown(); // 减少计数器
}
}使用ReentrantLock（可重入锁）
ReentrantLock提供了更灵活的锁机制，可以手动控制锁的获取和释放，适用于复杂并发场景。
import java.util.concurrent.locks.ReentrantLock;
public class LockExample {
private static final ReentrantLock lock = new ReentrantLock();
public void lockedTask() {
lock.lock();
try {
// 执行并发受限的任务
} finally {
lock.unlock();
}
}
}使用synchronized关键字
synchronized是最基础的并发控制方式，通过同步代码块或方法限制线程访问。
public class SynchronizedExample {
private final Object lock = new Object();
public void synchronizedTask() {
synchronized (lock) {
// 执行并发受限的任务
}
}
}选择合适的方法
- Semaphore：适用于限制资源访问数量，如数据库连接池。
- ThreadPoolExecutor：适用于任务队列和线程生命周期管理。
- CountDownLatch：适用于协调多个线程的启动或结束。
- ReentrantLock：适用于需要更复杂锁控制的场景。
- synchronized：适用于简单的同步需求，性能要求不高时。
