Java关于ExecutorService线程池的使用简介

最新推荐文章于 2024-05-29 15:03:52 发布

xhwang_DN

最新推荐文章于 2024-05-29 15:03:52 发布

阅读量2.2k

点赞数 2

分类专栏： java基础

本文链接：https://blog.csdn.net/xiao_hong_mao_sg/article/details/79578726

版权

java基础专栏收录该内容

2 篇文章 0 订阅

订阅专栏

首先在用之前，我们心中应该有线程池是什么，它是干什么的，为什么要用它。

线程池的作用:

线程池作用就是限制系统中执行线程的数量。
根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池:

减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务
可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多(未死亡)的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。
　　在Java5之前，要实现一个线程池是相当有难度的，现在Java5为我们做好了一切，我们只需要按照提供的API来使用，即可享受线程池带来的极大便利。
　　Java5的线程池分好多种：固定尺寸的线程池、可变尺寸连接池。

ExecutorService 扩展了Executor并添加了一些生命周期管理的方法。一个Executor的生命周期有三种状态

运行、关闭和终止。它其实才是正真的线程池管理者。

Executor创建时处于运行状态。当调用ExecutorService.shutdown()后，处于关闭状态，isShutdown()方法返回true。这时，不应该再向Executor中添加任务，所有已添加的任务执行完毕后，Executor处于终止状态，isTerminated()返回true。如果Executor处于关闭状态，往Executor提交任务会抛出unchecked exception RejectedExecutionException

Executors工厂类，它可以帮助我们很方便的创建各种类型ExecutorService线程池，Executors一共可以创建四类线程池：（查看代码）

一、简介 ExecutorService 使用方法

execute(Runnable)
submit(Runnable) 主要介绍这两个方法的区别
submit(Callable)
invokeAny()
invokeAll()

submit(Runnable)

方法 submit(Runnable) 同样接收一个Runnable 的实现作为参数，但是会返回一个Future 对象。这个Future 对象可以用于判断 Runnable 是否结束执行。如下是一个ExecutorService 的 submit() 方法的例子：

Future future = executorService.submit(new Runnable() {
public void run() {
System.out.println("Asynchronous task");
}
});
//如果任务结束执行则返回 null
System.out.println("future.get()=" + future.get());

submit(Callable)

方法 submit(Callable) 和方法 submit(Runnable) 比较类似，但是区别则在于它们接收不同的参数类型。Callable 的实例与 Runnable 的实例很类似，但是 Callable 的 call() 方法可以返回一个结果。方法 Runnable.run() 则不能返回结果。

Callable 的返回值可以从方法 submit(Callable) 返回的 Future 对象中获取。如下是一个 ExecutorService Callable 的样例：

Java代码

Future future = executorService.submit(new Callable(){
public Object call() throws Exception {
System.out.println("Asynchronous Callable");
return "Callable Result";
}
});
System.out.println("future.get() = " + future.get());

上述样例代码会输出如下结果：

Java代码

Asynchronous Callable
future.get() = Callable Result

二、简介

1）线程池类为 java.util.concurrent.ThreadPoolExecutor，常用构造方法为：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler)

参数讲解：
corePoolSize：线程池维护线程的最少数量
maximumPoolSize：线程池维护线程的最大数量
keepAliveTime：线程池维护线程所允许的空闲时间
unit：线程池维护线程所允许的空闲时间的单位
workQueue：线程池所使用的缓冲队列
handler：线程池对拒绝任务的处理策略
unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。
workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue
handler有四个选择：
ThreadPoolExecutor.AbortPolicy()
直接抛出java.util.concurrent.RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy()
重试添加当前的任务，他会自动重复调用execute()方法，交由调用者线程来执行此Runnable任务
ThreadPoolExecutor.DiscardOldestPolicy()
抛弃旧的任务
ThreadPoolExecutor.DiscardPolicy()
抛弃当前的任务

2）一个任务通过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。

当一个任务通过execute(Runnable)方法欲添加到线程池时：

如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。
如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。
如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。

也就是：处理任务的优先级为：
核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。先填满corepoolSize,然后在填满缓存队列，然后填满maximumplloSize,最后处理拒绝任务。

当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

下面主要介绍实现类ThreadPoolExecutor的简单使用

public class ThreadPoolExecutorTest
{
private static int queueDeep = 4;
public void createThreadPool()
{
/*
* 创建线程池，最小线程数为2，最大线程数为4，线程池维护线程的空闲时间为3秒，
缓冲队列为4，线程执行时间是3秒。
*/
ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 4, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(queueDeep),
new ThreadPoolExecutor.DiscardOldestPolicy()); //这里采取的是抛弃旧的任务
// 向线程池中添加 10 个任务
for (int i = 0; i < 10; i++)
{
try
{
Thread.sleep(1);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
while (getQueueSize(tpe.getQueue()) >= queueDeep)
{
System.out.println("队列已满，等3秒再添加任务");
try
{
Thread.sleep(3000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
TaskThreadPool ttp = new TaskThreadPool(i);
System.out.println("put i:" + i);
tpe.execute(ttp);
}
tpe.shutdown();
}
private synchronized int getQueueSize(Queue queue)
{
return queue.size();
}
public static void main(String[] args)
{
ThreadPoolExecutorTest test = new ThreadPoolExecutorTest();
test.createThreadPool();
}
class TaskThreadPool implements Runnable
{
private int index;
public TaskThreadPool(int index)
{
this.index = index;
}
public void run()
{
System.out.println(Thread.currentThread() + " index:" + index);
try
{
Thread.sleep(3000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
}
}
这里执行的结果为：

put i:0　　　　　　　　　　　　　　　　　　　　　　0加入进去池子
Thread[pool-1-thread-1,5,main] index:0　　　　　0开始执行
put i:1　　　　　　　　　　　　　　　　　　　　　　1加入进去池子
Thread[pool-1-thread-2,5,main] index:1 　　　 1开始执行
put i:2　　　　　　　　　　　　　　　　　　　　　　2加入缓冲
put i:3　　　　　　　　　　　　　　　　　　　　　　3加入缓冲
put i:4　　　　　　　　　　　　　　　　　　　　　　4加入缓冲
put i:5　　　　　　　　　　　　　　　　　　　　　　5加入缓冲
队列已满，等3秒再添加任务

（上述代码首先一次性执行，会在这里停一会，因为添加线程不需要时间）
Thread[pool-1-thread-1,5,main] index:2　　　　2开始执行
Thread[pool-1-thread-2,5,main] index:3　　　　3开始执行
put i:6　　　　　　　　　　　　　　　　　　　　　6加入缓冲
put i:7　　　　　　　　　　　　　　　　　　　　　7加入缓冲
队列已满，等3秒再添加任务

（会停一会，因为任务执行要3秒时间，2,3,4,5会先执行2,3 ，因为2,3先进入缓冲队列）
Thread[pool-1-thread-1,5,main] index:4
Thread[pool-1-thread-2,5,main] index:5
put i:8
put i:9

（停一会，任务执行要3秒，）
Thread[pool-1-thread-1,5,main] index:6
Thread[pool-1-thread-2,5,main] index:7

（要停一会，任务执行要3秒）
Thread[pool-1-thread-1,5,main] index:8
Thread[pool-1-thread-2,5,main] index:9

（执行完毕）

ps:这里是当队列已满时线程就一直等待了，不会再新创建线程，所以一直就只有1和2两个线程来执行。

---> 如果把这行去掉 while (getQueueSize(tpe.getQueue()) >= queueDeep){}

put i:0

Thread[pool-1-thread-1,5,main] index:0

put i:1

Thread[pool-1-thread-2,5,main] index:1

put i:2

put i:3

put i:4

put i:5

put i:6

Thread[pool-1-thread-3,5,main] index:6

put i:7

Thread[pool-1-thread-4,5,main] index:7

put i:8

put i:9

Thread[pool-1-thread-1,5,main] index:4

Thread[pool-1-thread-2,5,main] index:5

Thread[pool-1-thread-3,5,main] index:8

Thread[pool-1-thread-4,5,main] index:9

ps:这个执行顺序是0，1两个任务先进来，分别由线程1,2来执行，然后2,-5进来，队列满，6任务进来，因为队列已满，且1,2线程还未执行完，没有可用的线程，所以创建新的线程来运行6。7任务同理。然后8任务进来，队列已满，且1,2,3,4线程未执行完，线程数又等于了最多4个线程的限制，这时看线程池的执行策略为DiscardOldestPolicy,就是抛弃旧的任务，故开始进队列的2任务被抛弃，3任务同理，8,9任务进入队列，然后这时1-4线程已经执行完自己的任务，开始执行队列中的4,5,8,9

如果更改执行策略，那么相应的结果也会不一样，如果不希望有任务被抛弃，那么可以采用CallerRunsPolicy()策略

xhwang_DN

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Java关于ExecutorService线程池的使用简介

首先在用之前，我们心中应该有线程池是什么，它是干什么的，为什么要用它。线程池的作用: 线程池作用就是限制系统中执行线程的数量。根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，...
复制链接

扫一扫

专栏目录