Java中的线程池使用详解

文章目录

Java中的线程池使用详解
- 一、引言
- 二、线程池的创建与使用
- - 1、线程池的创建
  - - 1.1、FixedThreadPool（固定大小线程池）
    - 1.2、CachedThreadPool（可缓存线程池）
    - 1.3、SingleThreadExecutor（单线程化线程池）
    - 1.4、ScheduledThreadPool（定时及周期性任务线程池）
- 三、总结

Java中的线程池使用详解

一、引言

在Java中，线程池是一种执行器（Executor），用于在一个后台线程中执行任务。线程池的主要目的是减少在创建和销毁线程时所产生的性能开销。通过重用已经创建的线程来执行新的任务，线程池提高了程序的响应速度，并且提供了更好的系统资源管理。

二、线程池的创建与使用

在这里插入图片描述

1、线程池的创建

Java提供了多种线程池，每种线程池都有其特定的使用场景。以下是几种常用的线程池及其创建方式：

1.1、FixedThreadPool（固定大小线程池）

适用于负载相对平稳的场景，线程数量固定，不会频繁地创建和销毁线程，效率较高。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class FixedThreadPoolExample {public static void main(String[] args) {ExecutorService executor = Executors.newFixedThreadPool(5);for (int i = 0; i < 10; i++) {Runnable worker = new WorkerThread("" + i);executor.execute(worker);}executor.shutdown();while (!executor.isTerminated()) {}System.out.println("所有任务已完成");}
}class WorkerThread implements Runnable {private String command;WorkerThread(String s) {this.command = s;}@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + " 开始. 命令 = " + command);processCommand();System.out.println(Thread.currentThread().getName() + " 结束.");}private void processCommand() {try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}}@Overridepublic String toString() {return this.command;}
}

1.2、CachedThreadPool（可缓存线程池）

根据需要创建新线程，但如果之前创建的线程可用，就会重用它们。适合于任务数量动态变化的场景。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class CachedThreadPoolExample {public static void main(String[] args) {ExecutorService executor = Executors.newCachedThreadPool();for (int i = 0; i < 10; i++) {final int taskId = i;executor.execute(() -> {System.out.println("Task " + taskId + " is executing by " + Thread.currentThread().getName());try {Thread.sleep(2000); // 模拟任务执行时间} catch (InterruptedException e) {e.printStackTrace();}System.out.println("Task " + taskId + " completed.");});}executor.shutdown();}
}

1.3、SingleThreadExecutor（单线程化线程池）

只有一个线程在工作，保证了所有任务都在同一个线程按顺序执行，适用于需要保证执行顺序的场景。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class SingleThreadExecutorExample {public static void main(String[] args) {ExecutorService executorService = Executors.newSingleThreadExecutor();for (int i = 0; i < 10; i++) {Runnable task = new Task(i);executorService.execute(task);}executorService.shutdown();}
}class Task implements Runnable {private final int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());}
}

1.4、ScheduledThreadPool（定时及周期性任务线程池）

特别适合需要执行定时或周期性任务的场景。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;public class ScheduledThreadPoolExample {public static void main(String[] args) {ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);Runnable task = new Task(1);scheduledExecutorService.schedule(task, 5, TimeUnit.SECONDS);scheduledExecutorService.shutdown();}
}class Task implements Runnable {private final int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());}
}