文章目录
一、FutureTask 使用流程
二、FutureTask 模拟 AsyncTask 执行过程
三、AsyncTask 执行过程回顾
四、FutureTask 分析
一、FutureTask 使用流程
FutureTask 使用流程 :
① 自定义 Callable 类型 : 实现 Callable<String> 接口 , 实现 call() 方法 , 返回值 String 类型 ;
② 创建 FutureTask 对象 : new FutureTask<String>(new MyCallable()) , 其返回值是 String 类型 , 传入 MyCallable 对象 ;
③ 创建线程池 : 调用 Executors.newCachedThreadPool() 创建线程池 ;
④ 执行 FutureTask 任务 : 调用线程池 executorService.execute(futureTask) 执行 FutureTask 任务 ;
二、FutureTask 模拟 AsyncTask 执行过程
1 . FutureTask 任务 : 普通的线程执行是无法获取到执行结果的 , FutureTask 间接实现了 Runnable 和 Future 接口 , 可以得到子线程耗时操作的执行结果 , AsyncTask 异步任务就是使用了该机制 ;
2 . 执行完毕自动回调方法 : FutureTask<String> 的 done() 方法 , 是在 在 MyCallable 的 call() 方法执行完毕后 , 自动回调的方法 ;
3 . 获取执行结果 :
① 获取执行结果 : 在 FutureTask<String> 类中 , 调用 get() 方法 , 可以获取 MyCallable 的 call 方法耗时操作的结果 , 获取的值的类型是 FutureTask<String> 的泛型类型 String 类型 ;
② 非阻塞获取执行结果 : 注意 FutureTask 对象的 get() 最好在 done 中调用 , 可以 立刻得到异步操作的执行结果 ;
③ 阻塞获取执行结果 : 如果调用 get() 方法时 , Callable 的 call() 方法还没有执行完毕 , 此时调用线程就会一直阻塞 , 直到 call() 方法是调用完毕 , 返回执行结果 , 此时才会解除阻塞 , 返回执行结果 ;
4 . 代码示例 :
package kim.hsl.aa;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class MainActivity extends AppCompatActivity {
public static final String TAG = "MainActivity";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 手写 AsyncTask
future();
}
private void future(){
/*
FutureTask 间接实现了 Runnable 和 Future 接口 ,
可以得到子线程耗时操作的执行结果 , AsyncTask 异步任务就是使用了该机制 ;
需要开发者传入 Callable 或者 Runnable 实现类对象 , 在该对象中定义要在子线程中执行的操作
*/
FutureTask<String> futureTask = new FutureTask<String>(new MyCallable()){
/**
* 该方法在 MyCallable 的 call() 方法执行完毕后
* 自动回调
*/
@Override
protected void done() {
try {
/*
获取 MyCallable 的 call 方法耗时操作的结果
注意 FutureTask 对象的 get() 最好在 done 中调用 , 可以立刻得到异步操作的执行结果
如果调用 get() 方法时 , Callable 的 call() 方法还没有执行完毕 ,
此时调用线程就会一直阻塞 , 直到 call() 方法是调用完毕 ,
返回执行结果 , 此时才会解除阻塞 , 返回执行结果 ;
*/
String callableResult = get();
Log.i(TAG, "执行结果 : " + callableResult);
} catch (ExecutionException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
// 创建线程池 , 通过该线程池执行
ExecutorService executorService = Executors.newCachedThreadPool();
// 执行 futureTask 耗时操作
executorService.execute(futureTask);
}
/**
* 自定义 Callable 类型
* 实际的异步操作在该方法中执行
*/
class MyCallable implements Callable<String>{
@Override
public String call() throws Exception {
Log.i(TAG, "MyCallable call() 耗时操作");
return "Success";
}
}
}
5 . 执行结果 :
2020-07-10 20:15:30.724 4325-4461/kim.hsl.aa I/MainActivity: MyCallable call() 耗时操作
2020-07-10 20:15:30.724 4325-4461/kim.hsl.aa I/MainActivity: 执行结果 : Success
三、AsyncTask 执行过程回顾
AsyncTask 异步任务执行流程 :
① 构造函数中 :
创建 Callable 任务 : 创建 WorkerRunnable , 这是 Callable 接口的抽象类 ;
创建了 FutureTask 任务 : 该任务线程执行可以 返回线程执行结果 ;
上述 WorkerRunnable 对象 , 就是 传递给 FutureTask 的参数 , 与实际的后台任务方法 doInBackground() 就是执行的 WorkerRunnable 的 call() 方法 ;
② 执行异步任务 : 使用 SerialExecutor 自定义的串行线程池 , 调用 SerialExecutor 对象的 execute 方法 , 执行 FutureTask 任务 ;
四、FutureTask 分析
FutureTask<V> 是一个可取消的异步运算 ; 该类提供了一个 Future 实现 , 包含了如下方法 :
开始计算的过程
取消计算过程
检查计算是否完成
获取计算结果
计算结果只能在计算完毕之后获取 ; 如果计算没有完成 , 计算方法将会阻塞 ;
计算过程是一次性的 , 计算已经完成后 , 无法重新开始或取消 , 除非调用重置方法
该类实现了 RunnableFuture 接口 ;
/**
* 一个可取消的异步计算 ;
* 该类提供了一个 Future 实现 , 包含了如下方法 :
* - 1. 开始计算的过程
* - 2. 取消计算过程
* - 3. 检查计算是否完成
* - 4. 获取计算记过
* 计算结果只能在计算完毕之后获取 ;
* 如果计算没有完成 , 计算方法将会阻塞 ;
* 计算过程是一次性的 , 计算已经完成后 , 无法重新开始或取消 , 除非调用重置方法
*/
public class FutureTask<V> implements RunnableFuture<V> {
}
RunnableFuture 接口说明 : 既是 Future , 又是 Runnable ; 执行 run 方法后 , Future 也同时完成 , 并且允许查询执行结果 ;
/**
* 既是 Future , 又是 Runnable ;
* 执行 run 方法后 , Future 也同时完成 , 允许查询执行结果 ;
*
* @param <V> 返回结果 , V 泛型类型
*/
public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* 为计算的执行结果设置这个 Future , 除非该任务被取消 ;
*/
void run();
}
