AsnycTaskLearning

AsyncTask有四个重要的回调onPreExecute、doInBackground, onProgressUpdate 和 onPostExecute。另外还有一个执行函数execute.

他们的调用执行顺序：

---

onPreExecute（ui线程）--> doInBackground(新线程) -->onPostExecute

onProgressUpdate会在doInBackground过程中调用，但是它执行在ui线程中

---

如果把上面的看做需求，改如何实现？

version1 对应代码AsyncTask；

version2 对应代码AsyncTaskS;

version 1

1. 四个函数的调用其实是ui线程和另外一个线程来回切换过程，必然想到用Handler实现。
2. 新的线程可以用 new Thread（）来实现
3. 内部定义一个publishProgress函数， 在doInBackground里调用，用来执行onProgressUpdate
4. 伪代码：

class InternalHandler extends Handler{
    @Override
    public void handleMessage(Message msg) {
    
        switch (msg.what)
            case MESSAGE_POST_RESULT:
                onPostExecute(参数1);
                break;
            case MESSAGE_POST_PROGRESS:
                onProgressUpdate(参数3);
                break;
        }
    }
}

onPreExecute();
new Thread(new Runnable(){
参数1 = doInBackground(参数2);
    mHandler.obtainMessage(MESSAGE_POST_RESULT,参数1).sendToTarget();
}).start()

publishProgress(参数3) {
        mHandler.obtainMessage(MESSAGE_POST_PROGRESS,参数3).sendToTarget();
    }

参数定义

先根据需求讨论一下不确定类型的参数：

1. execute函数允许传入一个参数（Params）。

2. doInBackground 执行完返回值的参数(Result)。

3. onProgressUpdate 也需要传入一个中间过程的值的参数(Progress)。

因为都是未知，提供开发者来定义的，使用泛型：

public AsyncTask<Param,Progress,Result>{
    
}

根据上面的分析，可以确定伪代码中的中文参数了：

参数	类型
参数1	Result
参数2	Params
参数3	Progress

---

现在还有一处是不确定的：

Handler里对应的handleMessage函数的 参数1，参数5.

为了不用根据消息类型判断参数的类型，这里选择封装消息参数：

class AsyncResult<Data>{
        private Data[] mdata;
        private AsyncTask mtask;
        public AsyncResult(AsyncTask task,Data... data) {
            mtask = task;
            mdata = data;
        }
    }

在这里 Data类型对应Result，Progress两种类型。

关于这个版本，相信经常写java的人，只要了解需求，很快就能实现。

---

version2

1. 在版本1的基础上，加入线程管理
2. 使用ThreadPoolExecutor替换Thread,
3. 封装ThreadPoolExecutor，实现线程的串行

---

ThreadPoolExecutor的定义：

//use ThreadPoolExecutor replace Thread
    private static final int CORE_SIZE = 5;
    private static final int CORE_MAX_SIZE = 128;
    private static final int KEEP_LIVE =1;

    private static final BlockingDeque<Runnable> mblockingDeque = new LinkedBlockingDeque<Runnable>();

    private static final ThreadPoolExecutor mDefaultThread =
            new ThreadPoolExecutor(CORE_SIZE,CORE_MAX_SIZE,KEEP_LIVE, TimeUnit.SECONDS,mblockingDeque,new ThreadFactory(){

                @Override
                public Thread newThread(@NonNull Runnable r) {
                    return new Thread(r);
                }
            });

SerialExecute（串行）

private static class SerialExecute implements Executor{
        ArrayDeque<Runnable> arrayDeque = new ArrayDeque<Runnable>();
        Runnable mActive;
        @Override
        public synchronized void execute(@NonNull final Runnable command) {
            arrayDeque.offer(new Runnable() {
                @Override
                public void run() {
                    try {
                        command.run();
                    }finally {
                        sheduleNext();
                    }
                }
            });
            if(mActive == null){
                sheduleNext();
            }
        }

        public synchronized void sheduleNext(){
            if((mActive = arrayDeque.poll()) != null){
                mDefaultThread.execute(mActive);
            }
        }
    }

---