引言
@RequestMapping(value = "/socialInsuPayStatus",method =RequestMethod.PUT)
public Callable<?> compSocialPay(@RequestBody ParamDto paramDto ){
return ()-> bizService.compSocialInsuPay(paramDto );
}
这是之前项目要求的接口风格,返回了一个Callable对象,大家可以先思考一下这么写有什么优点?
正文
1)首先看一下这几个类的结构关系:
主要作用:
Ruuable表示可被Thread执行的任务,它的run方法没有返回值,解决java 单继承的问题,将该实现传入thread类来启动。
Callable表示可以调用的任务,它的call方法可以有返回值,可以抛出显式的异常
Future:线程调度器,是对异步执行的任务的控制,包括取消任务,判断任务状态,获取任务结果等操作
RunnableFuture是对Runnable接口和Future接口的适配,表示可以被控制状态的Runnable
RunnableAdapter是对Runnable和Callalbe的适配,实现了Callable接口,并聚合了Runnable对象
FutureTask实现了RunnableFuture接口,通过RunnableAdapter对传入的Callable和Runnable参数进行统一处理。
来看一下这几个类的完整执行流程:
//初始化线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
List<Future<Integer>> futures = new ArrayList<>();
for (int j = 1; j <= 10; j++) {
final int index = j;
Future<Integer> future = threadPool.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
//第三个线程睡眠等待
System.out.println("---------");
if (index == 3) {
Thread.sleep(3000l);
}
return index;
}
});
futures.add(future);
}
threadPool.shutdown();
for (Future<Integer> future : futures) {
System.out.println("线程:"+future.get()+" 任务执行结束:");
}
1)首先看一下 threadPool.submit()方法,在 AbstractExecutorService中:
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(Runnable runnable, T value) {
//实际返回的对象是 FutureTask
return new FutureTask<T>(runnable, value);
}
可以清晰看到这里实际上是将 callable实现 包装成 RunnableFuture,而RunnableFuture继承runnable接口,所以又作为参数在execute方法中执行,这个是线程池 ThreadPoolExecutor 中的方法。
其实这里也是线程池 execute 和 submit方法的区别与联系,顺便总结一下:
1)execute()方法只能进行任务的提交而不能获取该任务执行的结果, 但 submit()方法则既能进行任务的提交, 又能获取该任务执行的结果。
2)submit()方法就是对 execute()方法的一种封装, 它内部也是调用 execute()方法来实现任务提交的, 只是因为 submit()方法的返回值是一个 Future 对象。
2)future对象被包装成 worker对象,调用 addWorker() 方法,将线程加入到工作线程集合 workers中。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
//这里开始判断 线程数量和线程池中数量的大小,也就是线程池的几种状态
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
3)在 addWorker() 方法中,启动新线程来执行 worker 任务(futureTask对象此时被包装在 worker对象中)。
/** Delegates main run loop to outer runWorker */
public void run() {
//调用runWorker方法,执行当前对象包含的 futureTask任务对象
runWorker(this);
}
4)开始执行 futureTask 对象中的 run方法。
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 {
//这里开始执行真正的 callable对象
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
//如果执行结束,将执行结果设置到当前对象中的 outcome 变量上。
set(result);
}
} finally {
runner = null;
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
5)futureTask 获取执行结果。
public V get() throws InterruptedException, ExecutionException {
//判断线程执行状态
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
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);
}
整个流程到这里结束,实际上就是将 futureTask 来包装执行线程和执行结果,执行结束,用该对象来判断线程执行状态来获取结果。