目标
打算从以下几个方面进行分析:
1. Callable、Future、FutureTask、Runnable的关系;
2. 适配器模式;
3. FutureTask实例;
一、Callable、Future、FutureTask、Runnable的关系
1.1 Callable
public interface Callable {
V call() throws Exception;
}
1.2 Future
public interface Future {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit);
}
1.3 RunnableFuture
public interface RunnableFuture extends Runnable, Future {
void run();
}
1.4 Runnable
public interface Runnable {
public abstract void run();
}
1.5 FutureTask
// FutureTask拥有Runnable和Future的共性;
public class FutureTask implements RunnableFuture{
public FutureTask(Callable callable);
public FutureTask(Runnable runnable, V result)
boolean isDone();
void run();
V get();
V get(long timeout, TimeUnit unit);
V call();
}
从上面类的结构可以看出, FutureTask拥有Runnable与Future的共性, Future与Runnable的区别是后者有返回值, 而前者没有.
二、适配器模式
在分析FutureTask源码之前, 其实很有必要搞懂适配器模式的概念以及特点;
2.1 适配器概念
概念:
适配器模式把一个类的接口变换成客户端所期待的另一种接口, 从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作;
使用场景:
1、系统需要使用现有的类, 而此类的接口不符合系统的需要, 即接口不兼容.
2、想要建立一个可以重复使用的类, 用于与一些彼此之间没有太大关联的一些类, 包括一些可能在将来引进的类一起工作.
3、需要一个统一的输出接口, 而输入端的类型不可预知.
2.2 对象适配器
对象适配器模式把适配的类的API转换成目标类的API, 与类的适配器模式不同的是, 对象的适配器模式不是使用继承关系连接到Adaptee类, 而是使用代理关系连接到Adaptee类.
结合上图给出一个demo
// Target角色
public interface FiveVolt {
public int getVolt5();
}
// Adaptee角色, 需要被转换的对象
public class Volt220 {
public int getVolt220() {
return 220;
}
}
// 对象适配器模式
public class VoltAdapter implements FiveVolt {
Volt220 mVolt220;
public VoltAdapter(Volt220 adaptee) {
mVolt220 = adaptee;
}
public int getVolt220() {
return mVolt220.getVolt220();
}
@Override
public int getVolt5() {
return 5;
}
}
Adaptee类(Volt220)并没有提供getVolt5()方法, 而客户端则期待这个方法, 为使客户端能够使用Adaptee类, 需要提供一个包装类Adapter, 这个包装类包装了一个Adaptee的实例, 从而此包装类能够把Adaptee的API与Target类的API衔接起来, Adapter与Adaptee是委派关系.
一、单纯就FutureTask源码进行分析
1.1 FutureTask两个构造函数
FutureTask内部用到了适配器模式
private Callable callable;
// 这里直接对FutureTask内部的callable变量进行赋值;
public FutureTask(Callable callable) {
this.callable = callable;
this.state = NEW;
}
// 1. 注意这里, 其实我们也可以借鉴, 假如FutureTask支持Callable, 后来有需求需要支持Runnable,
// 可以考虑将Runnable转换为Callable类型, 当我们通过FutureTask触发Callable方法时, 实际是
// 调用了Callable内部的Runnable.run方法;
// 2. 结合1马上再描述一下适配器模式的概念:
// 将一个类的接口变换成客户端所期待的另一种接口, 从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作;
public FutureTask(Runnable runnable, V result) {
// 结合下面两段代码可知, 生成一个中间适配层RunnableAdapter, 然后通过call()最终调用Runnable.run()方法;
this.callable = Executors.callable(runnable, result);
this.state = NEW;
}
public class Executors {
public static Callable callable(Runnable task, T result) {
return new RunnableAdapter(task, result);
}
}
static final class RunnableAdapter implements Callable {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
// 这里返回传进来的result方法? 这个值肯定在某处被赋值了;
return result;
}
}
1.2 FutureTask.run
FutureTask通常都是配合线程池一起使用, 而我们知道, 线程池里面会触发Runnable.run的执行;
public void run() {
if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
return;
try {
Callable c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
// 1.这里触发了Callable.call()方法, 并且获取其返回值, 结合上文可知, 假如是以
// 第二种方式初始化的FutureTask, c实际指向中间适配层RunnableAdapter,
// c.call()内部最终调用了Runnable.run()方法;
// 2.而返回值就是我们在构造FutureTask时传进去的Result, 这里就很懵逼了, 初始化
// FutureTask时传进去Result, 任务还没开始, Result从何而来呢?
result = c.call();
ran = true;
if (ran)
// 当前Runnable.run()执行完成以后, 通过set(result)对outcome进行赋值, 从而
// 影响到get()方法;
set(result);
}
} finally {
runner = null;
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
1.3 FutureTask.get
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
// 这里就利用到了生产者-消费者模式, 如果当前任务没有完成, 则调用get()方法的
// 线程会一直阻塞在这里, 直到外部线程通过set(result)唤醒当前线程;
s = awaitDone(false, 0L);
return report(s);
}
分析完FutureTask源码之后, 还是有几个点不是很明白, 比如get()返回的result其实是在初始化FutureTask时传入的result, 这个result何时被赋值?
结合AsyncTask源码进行再次实战分析
二、从AsyncTask源码对FutureTask进行实战
2.1 AsyncTask两种调用方式:
1、创建AsyncTask对象, 自己实现doInBackground()方法, 然后调用execute()方法;
2、直接调用AsyncTask内部的静态execute()方法;
因为第一种方式用到了FutureTask, 所以先针对这种方式进行分析:
2.2 AsyncTask构造函数
public AsyncTask() {
mWorker = new WorkerRunnable<...>() {
public Result call() throws Exception {...}
};
mFuture = new FutureTask<...>(mWorker) {
@Override
protected void done() {...}
};
}
private static abstract class WorkerRunnable implements Callable {
Params[] mParams;
}
2.3 AsyncTask.execute(AsyncTask处理线程的第一种方式)
public final AsyncTask execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask executeOnExecutor(Executor exec, Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
// mState初始值Status.PENDING, 对于同一个AsyncTask对象, 第一次执行完execute
// 方法以后, mState = Status.RUNNING/Status.FINISHED, 再次调用execute方法以后,
// 抛出异常, 这点可以知道AsyncTask的局限性, 不支持连续多次调用execute方法;
case RUNNING:
throw new IllegalStateException("Cannot execute task:"
+ " the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
// 在这之前的操作都是在主线程中进行的, 下面代码进入到子线程中, 触发mFuture.run()的执行;
exec.execute(mFuture);
return this;
}
2.4 AsyncTask.execute(AsyncTask处理任务的第二种方式)
public static void execute(Runnable runnable) {
sDefaultExecutor.execute(runnable);
}
2.5 AsyncTask.sDefaultExecutor
public class AsyncTask {
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static class SerialExecutor implements Executor {
final ArrayDeque mTasks = new ArrayDeque();
Runnable mActive;
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
}
execute只接受Runnable对象, mActive实际指向FutureTask, 当Executor.execute(Runnable)时会触发Runnable内部run方法的执行, 而FutureTask此时接收的是Callable对象;
FutureTask_Callable :
public class FutureTask {
public FutureTask(Callable callable) {
this.callable = callable;
}
public void run() {
Callable c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
setException(ex);
}
if (ran)
set(result);
}
}
}
1、FutureTask内部的run()方法又是调用了Callable对象的call方法;
2、Future提供了一系列的控制线程周期的方法;通过AsyncTask的cancel控制FutureTask的生命周期;
所以四者的关系是:
1、由于Executor的execute()方法只接收Runnable, 并且会触发Runnable内部的run方法的执行, 所以FutureTask必须实现Runnable;
2、但是Runnable的run方法没有返回值, 而有些特殊情况又需要拿到最终线程执行的结果, 而Callable刚好可以拿到结果, 所以在其内部持有Callable的引用;
3、需要控制线程什么什么周期的问题, 而Future刚好提供了这些功能, 所以FutureTask又实现Future接口;
但是如果FutureTask需要支持Runnable怎么办?目前run方法内部实际调用的是Callable的call()方法:
所以适配器模式在这里发挥了作用, 也反映了适配器的一个特点, 是为了解决问题而生;
public class FutureTask {
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
}
}
public class Executors{
public static Callable callable(Runnable task, T result) {
return new RunnableAdapter(task, result);
}
private static final class RunnableAdapter implements Callable {
private final Runnable task;
private final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}
}
FutureTask构造函数支持传入Runnable对象, 可以看到此时传入的Runnable实际通过适配器模式被转化为了Callable对象, 而Callable实际指向RunnableAdapter, RunnableAdapter内部持有Runnable, 内部的call方法又会出发Runnable的run方法的执行;