【Android 异步操作】AsyncTask 异步任务 ( FutureTask 模拟 AsyncTask 执行过程 | AsyncTask 执行过程回顾 | FutureTask 分析 )

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";
        }
    }

}

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

/**
 * 一个可取消的异步计算 ; 
 * 该类提供了一个 Future 实现 , 包含了如下方法 : 
 *  - 1. 开始计算的过程 
 *  - 2. 取消计算过程 
 *  - 3. 检查计算是否完成
 *  - 4. 获取计算记过 
 * 计算结果只能在计算完毕之后获取 ; 
 * 如果计算没有完成 , 计算方法将会阻塞 ; 
 * 计算过程是一次性的 , 计算已经完成后 , 无法重新开始或取消 , 除非调用重置方法
 */
public class FutureTask<V> implements RunnableFuture<V> {
}

/**
 * 既是 Future , 又是 Runnable ; 
 * 执行 run 方法后 , Future 也同时完成 , 允许查询执行结果 ; 
 * 
 * @param <V> 返回结果 , V 泛型类型
 */
public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * 为计算的执行结果设置这个 Future , 除非该任务被取消 ; 
     */
    void run();
}