博主打算从0-1讲解下java进阶篇教学，今天教学第五篇：Java多线程编程。
在Java编程中，使用多线程可以提高程序的并发性能，但是直接创建和管理线程可能会导致资源浪费和性能下降。Java提供了线程池来管理线程的生命周期和执行任务，有效地提高了并发效率。本文将详细介绍如何使用Java线程池以及如何自定义线程池。
目录
一、线程简介
二、FixedThreadPool
三、CachedThreadPool
四、ScheduledThreadPool
五、SingleThreadPool
六、自定义线程池
一、线程简介
Java通过java.util.concurrent包提供了Executor框架来管理线程池。以下是使用线程池的步骤：
- 创建线程池：可以通过Executors工厂类来创建不同类型的线程池。常用的线程池类型包括FixedThreadPool、CachedThreadPool、ScheduledThreadPool、SingleThreadPool等。
- 提交任务：使用线程池的execute()或submit()方法提交任务给线程池执行。
- 关闭线程池：在不需要线程池时，需要及时关闭以释放资源。可以调用线程池的shutdown()或shutdownNow()方法来关闭线程池。
二、FixedThreadPool
FixedThreadPool是一个固定大小的线程池，它会创建指定数量的线程并保持这些线程的数量不变，即使线程处于空闲状态也不会销毁。
优点：
- 线程数量固定，不会随着任务数量的增加而增加，避免了线程数量过多导致的资源消耗问题。
- 可以控制线程的最大并发数，保证系统资源不被过度占用。
缺点：
- 固定大小的线程池可能会导致任务排队等待执行，如果任务数量过多，可能会导致性能下降。
- 线程池大小不可动态调整，如果在某些情况下需要更多的线程来处理任务，就无法满足需求。
案例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class FixedThreadPoolExample {
public static void main(String[] args) {
// 创建固定大小的线程池，包含5个线程
ExecutorService executor = Executors.newFixedThreadPool(5);
// 提交任务给线程池执行
for (int i = 0; i < 10; i++) {
executor.execute(new Task(i));
}
// 关闭线程池
executor.shutdown();
}
static class Task implements Runnable {
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
}
}
}
三、CachedThreadPool
CachedThreadPool是一个可缓存的线程池，它会根据需要创建新线程，并在旧线程可用时重用它们。如果线程在60秒内没有被使用，则会被终止并移除。
优点：
- 线程池的大小可以根据需要自动调整，无需手动设置线程数量，节省了资源并提高了性能。
- 可以灵活处理大量的短期任务，避免了长时间等待空闲线程的情况。
缺点：
- 可缓存的线程池会创建大量的线程，如果任务数量过多，可能会导致系统资源耗尽。
- 对于长时间执行的任务，线程池可能会频繁地创建和销毁线程，增加了系统开销。
案例：
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++) {
executor.execute(new Task(i));
}
// 关闭线程池
executor.shutdown();
}
static class Task implements Runnable {
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
}
}
}
四、ScheduledThreadPool
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) {
// 创建定时任务线程池，包含3个线程
ScheduledExecutorService executor = Executors.newScheduledThreadPool(3);
// 延迟1秒后执行任务，并每隔3秒执行一次
executor.scheduleAtFixedRate(new Task(), 1, 3, TimeUnit.SECONDS);
}
static class Task implements Runnable {
@Override
public void run() {
System.out.println("Task is running on thread " + Thread.currentThread().getName());
}
}
}
五、SingleThreadPool
SingleThreadPool是一个单线程的线程池，它只会创建一个工作线程来执行任务，保证所有任务按照指定顺序执行。
优点：
- 只有一个工作线程，保证任务按照指定顺序依次执行，避免了多线程情况下的竞争问题。
- 线程池的大小固定，不存在线程数量动态调整的问题。
缺点：
- 只有一个线程，无法并行处理多个任务，可能会导致任务执行时间过长。
- 如果任务出现阻塞或异常，可能会影响后续任务的执行。
案例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class SingleThreadPoolExample {
public static void main(String[] args) {
// 创建单线程的线程池
ExecutorService executor = Executors.newSingleThreadExecutor();
// 提交任务给线程池执行
for (int i = 0; i < 10; i++) {
executor.execute(new Task(i));
}
// 关闭线程池
executor.shutdown();
}
static class Task implements Runnable {
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
}
}
}
六、自定义线程池
除了使用Executors提供的线程池之外，我们还可以自定义线程池来满足特定的需求。在自定义线程池时，通常需要考虑以下七个参数：
- corePoolSize：核心线程数，即线程池中保持活动状态的最小线程数。
- maximumPoolSize：最大线程数，即线程池中允许的最大线程数。
- keepAliveTime：线程空闲时间，即当线程池中的线程数量超过corePoolSize时，多余的空闲线程等待新任务的最长时间。
- unit：keepAliveTime的时间单位。
- workQueue：工作队列，用于保存等待执行的任务。
- threadFactory：线程工厂，用于创建新线程。
- handler：拒绝策略，用于处理当工作队列已满并且无法继续接受新任务时的情况。
关于拒绝策略：
-
AbortPolicy（默认策略）：
- 在工作队列已满的情况下，直接抛出RejectedExecutionException异常，阻止任务的执行。这是默认的拒绝策略，意味着线程池无法接受新的任务时，会抛出异常来通知调用者。
-
CallerRunsPolicy：
- 当工作队列已满时，新提交的任务会由提交任务的线程来执行，即调用者所在的线程直接执行该任务。这样做可以减少任务的提交速度，以便控制任务的执行速度。
-
DiscardPolicy：
- 当工作队列已满时，会丢弃新提交的任务，而不做任何处理。这意味着新提交的任务将被静默地忽略，不会得到执行，也不会抛出异常。
-
DiscardOldestPolicy：
- 当工作队列已满时，会丢弃队列中最早提交的任务，然后尝试将新提交的任务添加到工作队列中。这样做可以确保工作队列中始终保留着最新的任务，但可能会丢失一些已提交的任务。
下面是一个自定义线程池的示例代码：
import java.util.concurrent.*;
public class CustomThreadPoolExample {
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // corePoolSize
5, // maximumPoolSize
10, // keepAliveTime
TimeUnit.SECONDS, // unit
new ArrayBlockingQueue<>(10), // workQueue
Executors.defaultThreadFactory(), // threadFactory
new ThreadPoolExecutor.AbortPolicy() // handler
);
// 提交任务给线程池执行
for (int i = 0; i < 10; i++) {
executor.execute(new Task(i));
}
// 关闭线程池
executor.shutdown();
}
static class Task implements Runnable {
private int taskId;
public Task(int taskId) {
this.taskId = taskId;
}
@Override
public void run() {
System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());
}
}
}
在自定义线程池中，我们通过构造方法来设置线程池的参数，包括corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory和handler。通过合理地配置这些参数，我们可以创建出满足不同需求的线程池。
通过本文的介绍，相信你已经对Java中的线程池有了更深入的理解，并能够灵活地使用和自定义线程池来提高程序的并发性能。
