Java并发编程：线程池与定时任务的实践案例

原创￡神魔★判官ぃ 2024-11-06 18:05 21阅读 0赞

Java并发编程中，线程池和定时任务是两个非常重要的概念。线程池可以帮助我们管理线程资源，提高效率，而定时任务则可以让我们按计划执行任务。下面是一个简单的实践案例，展示如何使用Java的`ExecutorService`和`ScheduledExecutorService`来实现线程池和定时任务。

###1.线程池的实现线程池可以帮助我们重用线程，减少创建和销毁线程的开销。Java提供了`ExecutorService`接口来管理线程池。

```javaimport 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 taskId = i;
 executor.submit(() -> {
 System.out.println("执行任务：" + taskId + ",线程：" + Thread.currentThread().getName());
 });
 }

// 关闭线程池 executor.shutdown();
 }
}
```###2.定时任务的实现定时任务可以帮助我们按计划执行任务。Java提供了`ScheduledExecutorService`接口来管理定时任务。

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

public class ScheduledTaskExample {
 public static void main(String[] args) {
// 创建一个定时任务线程池 ScheduledExecutorService scheduledExecutor = Executors.newScheduledThreadPool(2);

//定时任务：每隔2秒执行一次 scheduledExecutor.scheduleAtFixedRate(() -> {
 System.out.println("定时任务执行，线程：" + Thread.currentThread().getName());
},0,2, TimeUnit.SECONDS);

//延迟任务：延迟3秒后执行一次 scheduledExecutor.schedule(() -> {
 System.out.println("延迟任务执行，线程：" + Thread.currentThread().getName());
},3, TimeUnit.SECONDS);

//模拟长时间运行，以便观察定时任务的执行 try {
Thread.sleep(10 *1000);
} catch (InterruptedException e) {
e.printStackTrace();
 }

// 关闭定时任务线程池 scheduledExecutor.shutdown();
 }
}
```###3.综合案例下面是一个综合案例，展示如何结合线程池和定时任务来实现一个简单的任务调度器。

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

public class TaskScheduler {
 private final ScheduledExecutorService scheduledExecutor;

public TaskScheduler() {
 this.scheduledExecutor = Executors.newScheduledThreadPool(2);
 }

public void scheduleTask(Runnable task, long initialDelay, long period, TimeUnit unit) {
 scheduledExecutor.scheduleAtFixedRate(task, initialDelay, period, unit);
 }

public void shutdown() {
 scheduledExecutor.shutdown();
 }

public static void main(String[] args) {
 TaskScheduler taskScheduler = new TaskScheduler();

//定时任务：每隔2秒执行一次 taskScheduler.scheduleTask(() -> {
 System.out.println("定时任务执行，线程：" + Thread.currentThread().getName());
},0,2, TimeUnit.SECONDS);

//延迟任务：延迟3秒后执行一次 taskScheduler.scheduleTask(() -> {
 System.out.println("延迟任务执行，线程：" + Thread.currentThread().getName());
},3,0, TimeUnit.SECONDS);

//模拟长时间运行，以便观察定时任务的执行 try {
Thread.sleep(10 *1000);
} catch (InterruptedException e) {
e.printStackTrace();
 }

// 关闭任务调度器 taskScheduler.shutdown();
 }
}
```这个综合案例展示了如何使用`ScheduledExecutorService`来管理定时任务，并通过`TaskScheduler`类来封装任务调度的逻辑。通过调用`scheduleTask`方法，我们可以方便地添加定时任务和延迟任务。最后，通过调用`shutdown`方法来关闭任务调度器，释放资源。

希望这个实践案例对你有所帮助！如果你有任何其他问题，欢迎随时问我。