您的位置:首页 > 娱乐 > 八卦 > Java并发类API--Executor与ThreadPoolExecutor

Java并发类API--Executor与ThreadPoolExecutor

2024/12/23 11:55:08 来源:https://blog.csdn.net/sinat_33536503/article/details/141175903  浏览:    关键词:Java并发类API--Executor与ThreadPoolExecutor

在 Java 中,Executor 和 ThreadPoolExecutor 是用于管理线程和执行任务的工具,帮助开发者更好地控制多线程环境。下面是它们的使用和区别。

1.Executor 简介

Executor 是一个接口,用来创建线程池,它定义了一个 execute(Runnable command) 方法,用于执行传递进来的任务。它是 Java 中线程池的基础。

但Executor是接口,并不能直接使用,所以还得需要实现类,图4-3中所示的内容就是完整的Executor接口相关的类继承结构。

对于简单的线程管理,使用 Executor 接口或 Executors 工具类创建的线程池通常足够。这些工具提供了一些便捷的方法来创建常见类型的线程池,如固定大小的线程池、单线程执行器和缓存线程池。以下是几个常见的例子:

1.)使用 Executors.newFixedThreadPool(int nThreads)

创建一个固定大小的线程池,适用于需要固定数量线程执行任务的场景。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class FixedThreadPoolExample {public static void main(String[] args) {ExecutorService executor = Executors.newFixedThreadPool(3); // 创建一个包含3个线程的固定线程池for (int i = 0; i < 10; i++) {executor.execute(new Task(i));}executor.shutdown(); // 关闭线程池,等待所有任务完成}
}class Task implements Runnable {private int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());}
}

2) 使用 Executors.newSingleThreadExecutor()

创建一个单线程执行器,适用于需要按顺序执行任务的场景。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class SingleThreadExecutorExample {public static void main(String[] args) {ExecutorService executor = Executors.newSingleThreadExecutor(); // 创建一个单线程执行器for (int i = 0; i < 5; i++) {executor.execute(new Task(i));}executor.shutdown(); // 关闭执行器,等待所有任务完成}
}class Task implements Runnable {private int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());}
}

3.)使用 Executors.newCachedThreadPool()

创建一个缓存线程池,适用于短时间内需要大量并发、但不确定具体线程数量的场景。线程池会根据需要动态创建新线程,空闲线程超过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(); // 关闭线程池,等待所有任务完成}
}class Task implements Runnable {private int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());}
}

4) 使用 Executors.newScheduledThreadPool(int corePoolSize)

创建一个调度线程池,适用于需要周期性执行任务的场景。比如在固定的延迟后重复执行任务。

import java.util.concurrent.*;public class ScheduledThreadPoolExample {public static void main(String[] args) {ScheduledExecutorService executor = Executors.newScheduledThreadPool(2); // 创建一个调度线程池executor.scheduleAtFixedRate(new Task(1), 0, 2, TimeUnit.SECONDS); // 每2秒执行一次任务// executor.shutdown(); // 通常不需要立即关闭调度线程池,除非你确认所有任务已经完成}
}class Task implements Runnable {private int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());}
}

总结

newFixedThreadPool:适合需要固定数量线程来执行大量并发任务的场景。

newSingleThreadExecutor:适合任务必须顺序执行的场景。

newCachedThreadPool:适合任务数量波动大且需要高并发的场景。

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

这些工具类的简化了线程池的创建和管理,对于简单的线程管理场景,这些方法足够使用。

2. ThreadPoolExecutor 简介

ThreadPoolExecutor 是 Executor 接口的实现类,是 Java 中最灵活和可配置的线程池实现。它提供了丰富的配置选项,允许开发者自定义线程池的行为。

类ThreadPoolExecutor的方法列表:

构造函数:

ThreadPoolExecutor 的构造函数允许你设置以下参数:

corePoolSize: 核心线程数,当任务数量少于这个数目时,即使有空闲线程也不会被回收。

maximumPoolSize: 最大线程数,表示线程池中允许存在的最大线程数。

keepAliveTime: 当线程数量超过核心线程数时,多余空闲线程的存活时间。

unit: keepAliveTime 的时间单位。

workQueue: 用于保存等待执行任务的队列。

threadFactory: 用于创建新线程的工厂。

handler: 当任务无法被执行时的处理器。

使用示例:

import java.util.concurrent.*;public class ThreadPoolExecutorExample {public static void main(String[] args) {int corePoolSize = 2;int maximumPoolSize = 4;long keepAliveTime = 10;TimeUnit unit = TimeUnit.SECONDS;BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(2);ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,new ThreadPoolExecutor.CallerRunsPolicy() // 当线程池满时的策略);for (int i = 0; i < 10; i++) {executor.execute(new Task(i));}executor.shutdown();}
}class Task implements Runnable {private int taskId;public Task(int taskId) {this.taskId = taskId;}@Overridepublic void run() {System.out.println("执行任务 " + taskId + " 在线程 " + Thread.currentThread().getName());try {Thread.sleep(2000); // 模拟任务执行} catch (InterruptedException e) {e.printStackTrace();}}
}

解释

1. 创建 ThreadPoolExecutor

• 我们创建了一个线程池,核心线程数为2,最大线程数为4,使用一个容量为2的阻塞队列来保存任务。

• 当线程池中线程数超过 corePoolSize 时,空闲线程会在 keepAliveTime 时间内存活。

2. 提交任务

• 向线程池提交了10个任务。根据配置,最开始会创建2个核心线程,处理任务。接着会放入阻塞队列中,当队列满了之后,会创建新线程处理任务,直到达到 maximumPoolSize。如果线程池和队列都满了,则会执行指定的拒绝策略。

3. 拒绝策略

• 这里使用 CallerRunsPolicy,当线程池和队列都满时,任务会在调用 execute 的线程中执行。

4. 关闭线程池

• 使用 shutdown() 方法来关闭线程池,确保所有已提交的任务都会执行完毕。

总结

Executor: 是一个更简单的接口,用于任务的执行,但提供的功能有限。

ThreadPoolExecutor: 是一个更高级的实现,允许对线程池的大小、任务队列、线程超时、线程创建工厂等进行更详细的控制,适合需要高度自定义线程池行为的场景。

对于简单的线程管理,Executor 或使用 Executors 工具类创建的线程池足够了。但如果你需要更复杂的线程池管理,ThreadPoolExecutor 是一个强大的工具。

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com