今天遇到一个业务上的新需求,有新旧两个接口。现在业务上要求如果调用旧结果三秒没有返回就调用新的接口。百度了一下啊于是决定使用异步来处理这个需求。
在java 线程中提供了Callable 接口来让我实现有带返回参数的多线程方法。
其中Callable 和Future,FutureTask ,ExecutorService 经常配套使用
下面是Callable 的源码:
@FunctionalInterface
public interface Callable {
/**
* Computes a result, or throws an exception if unable to do so.
*得到一个结果 或者无法完成抛出一个异常
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
我们可以将需要的进行多线程的任务来实现这个接口。该接口支持lambada
Future 源码:
public interface Future {
/**
* 企图阻止该任务的执行。这可能会失败如果任务已经执行完毕的话或者已经被取消。
*/
boolean cancel(boolean mayInterruptIfRunning);
/**
* Returns {@code true} if this task was cancelled before it completed
* normally.
* 判断任务是否在完成前被取消
*/
boolean isCancelled();
/**
* Returns {@code true} if this task completed.
* 判断任务是否完成
*/
boolean isDone();
/**
* Waits if necessary for the computation to complete, and then
* retrieves its result.
* 获取到任务的返回结果。执行该方法的时候将会阻塞线程。
V get() throws InterruptedException, ExecutionException;
/**
* Waits if necessary for at most the given time for the computation
* to complete, and then retrieves its result, if available.
*等到一段指定的时间,如果任务没有返回则抛出超时异常
*/
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
我们可以通过该接口或者其实现类来判断任务是否已经完成
通常使用的子类为 FutureTask。当然使用方式也有点不一样。
ExecutorService 线程池就不多介绍了
来演示第一个demo:
package cn.myproject.hzq.ansy;
import java.util.concurrent.Callable;
/**
* 创建一个异步任务
* @author hzq
**/
public class AsyncTask implements Callable
再来创建一个测试例子
package cn.myproject.hzq.ansy;
import java.util.concurrent.*;
/**
* @author hzq
**/
public class FutureTest {
public static void main(String[] args){
ExecutorService executorService =
new ScheduledThreadPoolExecutor(5);
AsyncTask task = new AsyncTask();
//添加线程后会自己执行
Future future = executorService.submit(task);
try {
Thread.sleep(100);
System.out.println("主线程正在执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
future.get();
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
System.out.println("主线程执行完毕");
//关闭线程池。当然只是测试的时候需要,真实代码根据实际选择是否要关闭
executorService.shutdown();
}
}
在里面使用了Future的 第一种get 方式输出的结果为
异步线程执行
这时第0个循环
这时第1个循环
主线程正在执行
这时第2个循环
这时第3个循环
这时第4个循环
这时第5个循环
这时第6个循环
这时第7个循环
这时第8个循环
这时第9个循环
异步线程执行完毕
主线程执行完毕
现在使用第二种get 方式
package cn.myproject.hzq.ansy;
import java.util.concurrent.*;
/**
* @author hzq
**/
public class FutureTest {
public static void main(String[] args){
//创建线程池
ExecutorService executorService =
new ScheduledThreadPoolExecutor(5);
AsyncTask task = new AsyncTask();
//添加线程后会自己执行
Future future = executorService.submit(task);
try {
//主线程休眠
Thread.sleep(100);
System.out.println("主线程正在执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
//100ms 等待获取结果
future.get(100,TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
System.out.println("等待超时抛出异常,继续执行主线程");
e.printStackTrace();
}
System.out.println("主线程执行完毕");
//关闭线程池。当然只是测试的时候需要,真实代码根据实际选择是否要关闭
executorService.shutdown();
}
}
输出:
异步线程执行
这时第0个循环
这时第1个循环
主线程正在执行
这时第2个循环
等待超时抛出异常,继续执行主线程
java.util.concurrent.TimeoutException
at java.util.concurrent.FutureTask.get(FutureTask.java:205)
at cn.myproject.hzq.ansy.FutureTest.main(FutureTest.java:26)
主线程执行完毕
这时第3个循环
这时第4个循环
这时第5个循环
这时第6个循环
这时第7个循环
这时第8个循环
这时第9个循环
异步线程执行完毕
package cn.myproject.hzq.ansy;
import java.util.concurrent.*;
/**
* @author hzq
**/
public class FutureTaskTest {
public static void main(String[] args){
//创建线程池
ExecutorService executorService =
new ScheduledThreadPoolExecutor(5);
AsyncTask task = new AsyncTask();
//添加进入到FutureTask 中
FutureTask
执行结果
异步线程执行
这时第0个循环
这时第1个循环
主线程正在执行
这时第2个循环
等待超时抛出异常,继续执行主线程
java.util.concurrent.TimeoutException
at java.util.concurrent.FutureTask.get(FutureTask.java:205)
at cn.myproject.hzq.ansy.FutureTaskTest.main(FutureTaskTest.java:27)
主线程执行完毕
这时第3个循环
这时第4个循环
这时第5个循环
这时第6个循环
这时第7个循环
这时第8个循环
这时第9个循环
异步线程执行完毕
—与future差不多,就是比future 多了一些方法