并发控制工具的理解：Java.util.concurrent模块使用示例

原创ゝ一世哀愁。 2024-11-14 06:21 3阅读 0赞

在Java中，`java.util.concurrent`模块提供了一套高级的并发工具，这些工具可以帮助开发者更有效地处理多线程编程中的并发问题。以下是一些常用的并发控制工具及其使用示例：

###1. `ExecutorService`
`ExecutorService`是一个接口，用于管理线程池和任务执行。它提供了一种方法来异步执行任务。

```javaimport java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorServiceExample {
 public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(3); // 创建一个固定大小的线程池 executor.submit(() -> System.out.println("Task1 executed by " + Thread.currentThread().getName()));
 executor.submit(() -> System.out.println("Task2 executed by " + Thread.currentThread().getName()));
 executor.submit(() -> System.out.println("Task3 executed by " + Thread.currentThread().getName()));
 executor.shutdown(); // 关闭线程池 }
}
```###2. `CountDownLatch`
`CountDownLatch`是一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程等待。

```javaimport java.util.concurrent.CountDownLatch;

public class CountDownLatchExample {
 public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(3);
 for (int i =0; i <3; i++) {
 new Thread(() -> {
 System.out.println(Thread.currentThread().getName() + " is running");
 try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 latch.countDown(); //计数减1 }).start();
 }
 latch.await(); //等待计数器达到0 System.out.println("All tasks completed");
 }
}
```###3. `CyclicBarrier`
`CyclicBarrier`是一个同步辅助类，它允许一组线程相互等待，直到所有线程都到达某个公共屏障点。

```javaimport java.util.concurrent.CyclicBarrier;

public class CyclicBarrierExample {
 public static void main(String[] args) throws InterruptedException {
CyclicBarrier barrier = new CyclicBarrier(3, () -> System.out.println("All threads have reached the barrier"));
 for (int i =0; i <3; i++) {
 new Thread(() -> {
 System.out.println(Thread.currentThread().getName() + " is running");
 try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
 }
 try {
 barrier.await();
} catch (Exception e) {
e.printStackTrace();
 }
 }).start();
 }
 }
}
```###4. `Semaphore`
`Semaphore`是一个计数信号量，它用于限制对某些资源的访问。

```javaimport java.util.concurrent.Semaphore;

public class SemaphoreExample {
 public static void main(String[] args) {
Semaphore semaphore = new Semaphore(2); //允许两个线程同时访问资源 for (int i =0; i <5; i++) {
 new Thread(() -> {
 try {
 semaphore.acquire(); // 获取一个许可 System.out.println(Thread.currentThread().getName() + " is accessing the resource");
Thread.sleep(1000);
 semaphore.release(); //释放一个许可} catch (InterruptedException e) {
e.printStackTrace();
 }
 }).start();
 }
 }
}
```###5. `ReentrantLock`
`ReentrantLock`是一个可重入的互斥锁，它比`synchronized`关键字提供了更灵活的锁定机制。

```javaimport java.util.concurrent.locks.ReentrantLock;

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

public void doSomething() {
lock.lock();
 try {
 System.out.println(Thread.currentThread().getName() + " is doing something");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
 }
 }

public static void main(String[] args) {
ReentrantLockExample example = new ReentrantLockExample();
 for (int i =0; i <5; i++) {
 new Thread(example::doSomething).start();
 }
 }
}
```这些工具可以帮助你更有效地管理并发任务和资源，提高程序的性能和响应能力。