Java笔记(十七) 异步任务执行服务
异步任务执行服务
一、基本原理和概念
一)基本接口
1)Runnable和Callable:表示要执行的异步任务。
2)Executor和ExecutorService:表示执行服务。
3)Future:表示异步任务的结果。
Executor接口:
public interface Executor {
void execute(Runnable command);
}
ExecutorService扩展了Executor:
public interface ExecutorService extends Executor {
<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
}
这三个submit都只是表示任务已经提交,不代表已经执行,通过Future可以查询可以
查询异步任务的状态、获取最终结果、取消任务等。
public interface Future<V> {
//用于取消任务,如果任务还没有开始,则不再运行,如果任务已经在执行,则不一定能
//取消,参数mayInterruptIfRunning表示,如果任务已经在执行,是否调用interrupt
//方法中断线程,如果为false就不会,如果为true就会尝试线程中断,但中断也不一定取消
boolean cancel(boolean mayInterruptIfRunning);
//返回cancel方法的返回值,任务不一定被终止
boolean isCancelled();
//不管什么方式,只要任务结束,都返回true
boolean isDone();
//用于返回异步任务最终的结果,如果任务还未执行,会阻塞等待。
V get() throws InterruptedException, ExecutionException;
//限定等待时间,如果超时任务还没有结束,抛出异常TimeoutException
V get(long timeout, TimeUnit unit) throws InterruptedException,
ExecutionException, TimeoutException;
}
Future是一个重要的概念,是实现“任务的提交”与“任务的执行”相分离的关键,是其中的纽带,
任务提交者和任务执行服务通过它隔离各自的关注点,同时进行协作。
二)基本用法
public class BasicDemon {
static class Task implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int sleepSeconds = new Random().nextInt(1000);
Thread.sleep(sleepSeconds);
return sleepSeconds;
}
}
public static void main(String[] args) {
//使用一个线程执行所有服务
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(new Task());
//模拟执行其他任务
try {
Thread.sleep(1000);
System.out.println(future.get());
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
//关闭执行任务服务
executor.shutdown();
}
}
public interface ExecutorService extends Executor {
//表示不再接收新任务,但已经提交的任务会继续执行,即使任务还未开始
void shutdown();
//不接收新任务,终止已经提交但还尚未执行的任务,
// 对于已经执行的任务,用interrupt方法尝试中断。
//返回已经提交但尚未执行的任务列表
List<Runnable> shutdownNow();
//shutdown和shutdownNow不会阻塞等待,它们返回后不代表所有的任务都已结束
//不过isShutdown方法会返回true。
boolean isShutdown();
//所有任务都结束返回true
boolean isTerminated();
//等待所有任务结束
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
//等待所有任务完成,返回Future列表中,每个Future的isDone方法都返回true,
//但这并不代表任务执行成功,也可能是被取消了。
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
//指定等待时间,如果超时后有的任务没完成,就会被取消。
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
//只要有一个任务在限时内成功返回了,它就会返回该任务的结果,其他任务被取消
//如果没有任务能在限时内成功返回,抛出TimeoutException,如果限时内所有的任务
//都完成了,但都发生了异常,抛出ExecutionException.
<T> T invokeAny(Collection<? extends Callable<T>> tasks)throws InterruptedException, ExecutionException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
三)基本实现原理
ExecutorService的主要实现类是ThreadPoolExecutor,它是基于线程池实现的,
ExecutorService有一个抽象实现类AbstractExecutorService
1.AbstractExecutorService
该类提供了submit,invokeAll,invokeAny的默认实现,子类需要实现其他方法。
除了execute,其他方法都与执行服务的生命周期管理有关。submit/invokeAll/invokeAny
最终都会调用execute,我们来简单实现它们:
public void execute(Runnable command) {
new Thread(command).start();
}
public <T> Future<T> submit(Callable<T> task) {
if(task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
2.FutureTask
FutureTask实现了RunnableFuture接口。它的成员变量:
private Callable<V> callable;
整数变量state表示状态:
private volatile int state;
取值为:
NEW = 0; //任务在运行
COMPLETING = 1; //临时状态,任务即将结束,在设置结果
NORMAL = 2; //任务正常执行完成
EXCEPTIONAL = 3 //任务执行抛出异常结束
CANCELLED = 4; //任务被取消
INTERRUPTING = 5; //任务在被中断
INTERRUPTED = 6; //任务被中断
有一个变量表示最终的执行结果或异常:
private Object outcome;
有个变量表示运行任务的线程:
private volatile Thread runner;
有个单向链表表示等待任务的执行结果的线程:
private volatile WaitNode waiters;
构造方法:
public FutureTask(Runnable runnable, V result) {
//转化为Callable
this.callable = Executors.callable(runnable, result);
this.state = NEW; //ensure visibility of callable
}
任务执行服务:
public void run() {
if(state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if(c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if(ran)
set(result);
}
} finally {
//runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
//state must be re-read after nulling runner to prevent
//leaked interrupts
int s = state;
if(s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);}
}
其中,set和setException除了设置结果,修改状态外,还会调用finshCompletion,它会
唤醒所有等待结果的线程。
对于任务提交者,它通过get方法获取结果,限时get方法的代码为:
public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if(unit == null)
throw new NullPointerException();
int s = state;
if(s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
return report(s);
}
private V report(int s) throws ExecutionException {
Object x = outcome;
if(s == NORMAL)
return (V)x;
if(s >= CANCELLED)
throw new CancellationException();
throw new ExecutionException((Throwable)x);
}
public boolean cancel(boolean mayInterruptIfRunning) {
if(state != NEW)
return false;
if(mayInterruptIfRunning) {
if(!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING))
return false;
Thread t = runner;
if(t != null)
t.interrupt();
UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); // final state
}
else if(!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED))
return false;
//唤醒所有等待结果的线程
finishCompletion();
return true;
}
二、线程池
线程池是并发程序中一个非常重要的概念和技术。线程池主要由两个概念组成:
一是任务队列,另一个是工作者线程。工作者线程主体就是一个循环,循环从队列
中接受任务并执行,任务队列保存待执行的任务。线程池的优点:
1)可以重用线程,避免线程创建的开销;
2)任务过多时,通过排队避免创建过多线程,减少系统资源和竞争,确保任务有序完成。
Java并发包中线程池的实现类是ThreadPoolExecutor,它继承自AbstracExecutorService,
实现了ExecutorService.
一)理解线程池
主要构造方法:
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory, RejectedExecutionHandler handler)
1.线程池大小
corePoolSize:核心线程个数
maximumPoolSize:最大线程个数
keepAliveTime和unit:表示当线程池中线程个数大于corePoolSize时额外空闲线程的存活时间。
如果该值为0,表示所有线程都不会超时终止。
一般情况下,有新任务到来的时候,如果当前线程个数小于corePoolSize,就会创建一个新
线程来执行该任务,需要说明的是即使其他线程是空闲着的,也会创建新线程。不过,如果
线程个数大等于corePoolSize,那就不会立即创建新线程了,它会先尝试排队,需要强调的是
它是尝试排队,而不是阻塞等待入队,如果队列满了或者因为其他原因不能立即入队,它就不
会排队,而是检查线程个数是否达到了maximumPoolSize,如果没有,就会继续创建线程,直到
线程数达到maximumPoolSize。
查看关于线程和任务数的一些动态数字:
//返回当前线程个数
public int getPoolSize()
//返回线程池曾经达到过的最大线程数
public int getLargestPoolSize()
//返回线程池创建以来所有已完成的任务数
public long getCompletedTaskCount()
//返回所有任务数,包括已完成和在排队的
public long getTaskCount()
关于任务队列,需要强调的是,如果用的是无界队列,线程个数最多只能达到corePoolSize,
新的任务总会排队,参数maximumPoolSize也就没有意义。
2.任务拒绝策略
如果任务队列有界,且maximumPoolSize有限,则当队列排满,线程个数
也达到maximumPoolSize,这时,新任务来了就会触发线程池任务拒绝策略。
此时,默认情况下,默认情况下提交任务的方法(executoe/submit/invokeAll等)
会抛出RejectExecutionException。不过该策略可以自定义,ThreadPoolExecutor
实现了4种处理方式:
1)ThreadPoolExecutor.AbortPolicy:默认处理方式,抛异常;
2)ThreadPoolExecutor.DiscardPolicy:静默处理,忽略新任务,不抛异常也不执行;
3)ThreadPoolExecutor.DiscarOldestPolicy:将等待时间最长的任务扔掉,然后自己排队;
4)ThreadPoolExecutor.CallerRunsPolicy:在任务提交者线程中执行任务,而不是交给线程池中的线程执行。
他们都实现了RejectedExecutionHandler接口:
public interface RejectedExecutionHandler {
//当线程池不能接受任务时,调用该方法
void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}
默认的RejectedExecutionHandler:
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
3.线程工厂
ThreadFactory是一个接口:
public interface ThreadFactory {
Thread newThread(Runnable r);
}
这个接口根据Runnable创建一个Thread. ThreadPoolExecutor中线程的默认实现就是Execotors类中的静态内部类
DefaultThreadFactory,主要就是创建一个线程,给线程设置一个名称,设置daemon属性为false,设置线程的优先级
为标准默认优先级,线程的名称为:pool-<线程池编号>-thread-<线程编号>。可以自定义,实现该接口。
4.关于核心线程的特殊配置
当线程池中线程个数小等于corePoolSize时,线程池中的线程是核心线程,默认情况下:
核心线程不会预先创建,只有当有任务时才创建,核心线程不会因为空闲而终止。
ThreadPoolExecutor有如下方法,可以改变这些默认行为:
//预先创建所有核心线程
public int prestartAllCoreThreads()
//创建一个核心线程,如果所有核心线程都已经创建,则返回false
public boolean prestartCoreThread()
//如果参数为true,则keepAliveTime参数也适用于核心线程
public void allowCoreThreadTimeOut(boolean value)
二)工厂类Executors
该类提供了创建线程池的方法:
public static ExcutorService newSingleThreadExecutor() {
return new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
注意使用的是无界队列
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, 0L,
TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
}
创建固定线程个数的线程池,使用无界队列,线程创建后不会超时终止,
由于是无界队列,如果排队任务过多,可能会消耗过多内存。
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L,
TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
}
创建一个线程池,当新线程到来时,如果有空闲线程在等待任务,则其中一个空闲线程接受该任务,
否则就创建一个新线程,线程创建的总个数几乎不受限制,对于任意一个空闲线程,如果60秒内没有新任务,就终止。
思考,应该怎么选择线程池?
三)线程池死锁
自己思考。
三、定时任务的那些陷阱
在Java中主要有两种方式实现定时任务:
1)使用java.util包中的Timer和TimeTask
2)使用java并发包中的ScheduledExecutorService
一)Timer和TimeTask
1.基本用法
TimerTask表示一个定时任务,它是一个抽象类,实现了Runnable,具体的定时任务需要继承
该类,实现run方法。Timer是一个具体类,它负责定时任务的调度和执行:
//在指定的绝对时间运行task
public void schedule(TimerTask task, Date time)
//在当前时间延迟delay毫秒后执行
public void schedule(TimerTask task, long delay)
//固定延时重复执行,第一次计划执行时间为firstTime,
//后一次的计划执行时间为前一次的“实际”加上period,如果由于某种原因该次任务延时了,
//则本次任务也会延时,即延时时间period始终不变。
public void schedule(TimerTask task, Date firstTime, long period)
//同样是固定延时重复执行,第一次执行时间为当前时间加上delay
public void schedule(TimerTask task, long delay, long period)
//固定频率重复执行,第一次计划执行时间为firstTime
//后一次的计划执行时间为前一次的计划时间加上period
public void scheduleAtFixedRate(TimerTask task, Date firstTime, long period)
//
public void scheduleAtFixedRate(TimerTask task, long delay, long period)
注意固定延时和固定频率的区别。另外需要注意,如果第一个计划执行的时间firstTime是一个过去时,则任务会
立即执行,对于固定延时的任务,下次任务会基于第一次执行时间计算,而对于固定频率的任务,则会从firstTime
开始计算,有可能加上period还是一个过去时间,从而连续运行很多次,直到时间超过当前时间。
例子:
public class TimerFixedDelay { static String getNowTime() {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
return format.format(new Date());
} static class LongRunningTask extends TimerTask {
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Date date = new Date();
System.out.println("Long running task finished! And finish time is " + getNowTime() );
}
} static class DelayTask extends TimerTask {
public void run() {
System.out.println("Now the time is " + getNowTime());
}
} public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new LongRunningTask(), 10);
timer.schedule(new DelayTask(), 100, 1000);
/*Long running task finished! And finish time is 2018-12-24 04:50:29
Now the time is 2018-12-24 04:50:29
Now the time is 2018-12-24 04:50:30
Now the time is 2018-12-24 04:50:31
Now the time is 2018-12-24 04:50:32
Now the time is 2018-12-24 04:50:33
Now the time is 2018-12-24 04:50:35*/ // Timer timer1 = new Timer();
// timer1.schedule(new LongRunningTask(), 10);
// timer1.scheduleAtFixedRate(new DelayTask(), 100, 1000);
/*Long running task finished! And finish time is 2018-12-24 04:48:48
Now the time is 2018-12-24 04:48:48
Now the time is 2018-12-24 04:48:48 //补足了之前运行的代码
Now the time is 2018-12-24 04:48:48
Now the time is 2018-12-24 04:48:48
Now the time is 2018-12-24 04:48:48
Now the time is 2018-12-24 04:48:48
Now the time is 2018-12-24 04:48:49
Now the time is 2018-12-24 04:48:50
Now the time is 2018-12-24 04:48:51
Now the time is 2018-12-24 04:48:52
Now the time is 2018-12-24 04:48:53
Now the time is 2018-12-24 04:48:54
Now the time is 2018-12-24 04:48:55
Now the time is 2018-12-24 04:48:56*/
}
}
2.基本原理
Timer内部主要由任务队列和Timer线程两部分组成。任务队列是一个基于
堆实现的优先级队列,按照下次执行时间排优先级。Timer线程负责执行
所有的定时任务,注意,一个Timer对象只有一个Timer线程,所以对于上面的
例子,任务会被延迟。
Timer线程的主体是一个循环,从队列中获取任务,如果队列中有任务
且计划执行时间小等于当前时间,就执行它,如果队列中没有任务或者
第一个任务延时还没有到,就睡眠。如果睡眠过程中队列上添加新任务
是第一个任务,Timer线程就会被唤醒,重新进行检查。
在执行任务之前,Timer线程判断任务是否为周期任务,如果是就设置
下次执行时间并添加到优先级队列中,对于固定延时任务,下次执行时间
为当前时间加上period,对于固定频率任务,下次执行时间为上次计划时间加上period。
3.死循环
定时任务不能耗时太长,更不能是无限循环。
public class EndlessTimer {
static class LoopTask extends TimerTask {
public void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
} static class SimpleTask extends TimerTask {
public void run() {
System.out.println("Never happen!"); //永远不会被执行
}
} public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new LoopTask(), 100);
timer.schedule(new SimpleTask(), 100);
}
}
4.异常处理
在执行任何一个任务的run方法时,如果run方法抛出异常,Timer线程就会退出,
从而所有的定时任务都会被取消。所以,如果希望各个定时任务互不干扰,一定要在run方法内捕获异常。
二)ScheduledExecutorService
1.基本用法
ScheduledExecutorService是一个接口,其用法为:
public interface ScheduledExecutorService extends ExecutorService {
//单次执行,在指定时间delay后运行command
ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
//单次执行,在指定时间delay后运行callable
<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay,TimeUnit unit);
//固定频率重复执行
ScheduledFuture<?> scheduleAtFixedRate(Runnable command,long initialDelay, long delay, TimeUnit unit)
//固定延时重复执行
ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);
}
ScheduledExecutorServiced的主要实现类是SchedeuledThreadPoolExecutor,它是线程池
ThreadPoolExecutor的子类,其主要构造方法为:
public ScheduledThreadPoolExecutor(int corePoolSize)
它的任务队列是一个无界优先级队列。工厂类Executors也提供了一些方法,以创建SchedeuledThreadPoolExecutor:
//单线程定时任务
public static ScheduledExecutorService newSingleThreadScheduledExecutor()
public static ScheduledExecutorService newSingleThreadScheduledExecutor(
ThreadFactory threadFactory)
//多线程定时任务
public static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize)
public static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize, ThreadFactory threadFactory)
与Timer中的任务类似,应该捕获所有异常。
Java笔记(十七) 异步任务执行服务的更多相关文章
- Java编程的逻辑 (77) - 异步任务执行服务
本系列文章经补充和完善,已修订整理成书<Java编程的逻辑>,由机械工业出版社华章分社出版,于2018年1月上市热销,读者好评如潮!各大网店和书店有售,欢迎购买,京东自营链接:http: ...
- Java并发之ThreadPoolExecutor 线程执行服务
package com.thread.test.thread; import java.util.concurrent.ExecutorService; import java.util.concur ...
- Java笔记(十七)……异常
异常概述 异常是什么 是对问题的描述,将问题进行对象的封装 异常体系 Throwable |---Error |---Exception |---RuntimeException 异常体系的特点 异常 ...
- 多线程编程学习笔记——异步调用WCF服务
接上文 多线程编程学习笔记——使用异步IO 接上文 多线程编程学习笔记——编写一个异步的HTTP服务器和客户端 接上文 多线程编程学习笔记——异步操作数据库 本示例描述了如何创建一个WCF服务,并宿主 ...
- [学习笔记]java基础Java8SE开发环境搭建、第一个Java Hello World、Java程序的编译与执行
本文作者:sushengmiyan 本文地址:http://blog.csdn.net/sushengmiyan/article/details/25745945 内容简介: ------------ ...
- java笔记——java加载与执行
java的加载与执行过程: 编译阶段: 首先,我们先创建一个java源文件xxx.java 2. 经过javac.exe编译(如果源文件没有语法错误),生成一个或多个.class文件,注意的是此时的字 ...
- java笔记整理
Java 笔记整理 包含内容 Unix Java 基础, 数据库(Oracle jdbc Hibernate pl/sql), web, JSP, Struts, Ajax Spring, E ...
- JAVA中Socket的用法模拟服务端和客户端
<看透springMvc源代码分析与实践>学习笔记 Socket分为ServerSocket和Socket两个大类 ServerSocket用于服务端,可以通过accept方法监听请求,监 ...
- 转 Java笔记:Java内存模型
Java笔记:Java内存模型 2014.04.09 | Comments 1. 基本概念 <深入理解Java内存模型>详细讲解了java的内存模型,这里对其中的一些基本概念做个简单的笔记 ...
随机推荐
- mongoDB通过_id删除doc
转载: 点击查看原文 做项目遇到一个需求,需要根据mongodb数据记录里面的_id字段删除相应的docs,实际使用时发现直接如下使用 db.collection('infochanges').rem ...
- 创建Python虚拟环境
以window为例: 安装完python后, 打开cmd, 命令行输入: pip install virtualenv ,安装过程见截图 进入你想安装虚拟环境的目录, 命令行输入: virtualen ...
- jsp和
- python 装饰器(1)
# 装饰器,对一个函数打扮 # def foo():# print("foo")# foo# foo()# def test1():# print('-----1-----')# ...
- 正则 ?<= 和 ?= 用法,范例
(exp) 匹配exp,并捕获文本到自动命名的组里(?<name>exp) 匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name'exp)(?:exp) 匹配exp,不捕 ...
- postgresql 10 ssl 双向认证
https://blog.csdn.net/dna911/article/details/82819637
- C#学习-构造函数
如果没有为类显式地定义一个构造函数,则C#编译器会自动生成一个函数体为空的默认无参的实例构造函数. 构造函数主要用于创建类的实例对象. 当调用构造函数创建一个对象时,构造函数会为对象分配内存空间,并初 ...
- mycat配置文件备份
schema.xml <?xml version="1.0"?> <!DOCTYPE mycat:schema SYSTEM "schema.dtd&q ...
- mysql字符集问题汇总
1.设置mysql字符集:在my.ini中添加以下设置,没有my.ini可以将my_default.ini改成他.character-set-server=utf8[client]loose-defa ...
- Vue小问题汇总
1.element-UI等组件更改默认样式: >>> https://vue-loader-v14.vuejs.org/zh-cn/features/scoped-css.html ...