Java并发工具：线程池、定时器和信号量的使用示例

原创痛定思痛。 2024-10-15 13:09 53阅读 0赞

在Java中，我们可以使用java.util.concurrent包中的各种工具来管理并发。以下是线程池、定时器和信号量的使用示例：

1. 线程池：
线程池是一种常用的线程复用机制。以下是一个创建线程池并提交任务的例子：

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

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

// 提交任务到线程池
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executor.submit(() -> "Task " + index + " is being executed."));
        }

// 关闭线程池
        executor.shutdown();
    }
}
```

2. 定时器（ScheduledExecutorService）：
定时器允许你在未来的某个时间执行一个任务。以下是一个使用定时器的例子：

```java
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledTimerExample {
    public static void main(String[] args) {
        // 创建一个ScheduledExecutorService实例
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();

// 添加一个定时任务，将在5秒后执行
        executor.schedule(() -> "Task will be executed after 5 seconds."), 5, TimeUnit.SECONDS);

// 关闭ScheduledExecutorService
        executor.shutdown();
    }
}
```

3. 信号量（Semaphore）：
信号量是一种多线程同步机制。以下是一个使用信号量的例子：

```java
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    public static void main(String[] args) {
        // 创建一个信号量，初始值为1
        Semaphore semaphore = new Semaphore(1);

// 线程A，尝试获取信号量，但数量已满，则阻塞
        Thread threadA = new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println("Thread A acquired semaphore");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }));

// 线程B，尝试获取信号量，如果数量已满则等待，否则直接执行
        Thread threadB = new Thread(() -> {
            try {
                semaphore.acquire();
                System.out.println("Thread B acquired semaphore");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (!semaphore.tryAcquire()) {
                System.out.println("Semaphore is full, waiting for release...");
                try {
                    semaphore.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }));

// 启动两个线程
        threadA.start();
        threadB.start();

// 等待所有线程执行完毕
        threadA.join();
        threadB.join();

// 关闭信号量
        semaphore.releaseAll();
    }
}
```

以上就是Java并发工具中线程池、定时器和信号量的使用示例。