美文网首页
Android AsyncTask

Android AsyncTask

作者: just0119 | 来源:发表于2019-12-27 17:01 被阅读0次

    AsyncTask也是一种异步消息处理机制,用于处理耗时操作及其UI修改。其内部封装了Thread和Handler所以我们不需要手动切换线程

    首先还是看一下其简单使用

    internal class MyAsyncTask(activity: SecondActivity) :
            AsyncTask<String, Int, String>() {
    
            private val reference: WeakReference<SecondActivity> = WeakReference(activity)
    
            override fun onPreExecute() {
                super.onPreExecute()
                reference.get()?.mBtn?.text = "start"
            }
    
            override fun doInBackground(vararg strings: String): String? {
                Log.d("cjq",strings[0])
                var i = 0
                while (true) {
                    publishProgress(i++)
                    Thread.sleep(20)
                    if (i >= 20) break
                }
                return "End"
            }
    
            override fun onProgressUpdate(vararg values: Int?) {
                super.onProgressUpdate(*values)
                Log.d("cjq","${values[0]}")
                reference.get()?.mBtn?.text = "${values[0]}"
            }
    
            override fun onPostExecute(s: String) {
                super.onPostExecute(s)
                reference.get()?.mBtn?.text = s
            }
        }
    

    开始执行任务调用

     val string = arrayOf("qw","we")
     mAsyncTask.execute(*string)
    
    1. 从例子来看有3个需要指定的参数类型
    • pamars 输入参数,在调用execute可以传入,也是doInBackground方法的参数类型
    • prograss 下载的进度类型,也是onProgressUpdate方法的参数类型
    • result 返回类型,是doInBackground的返回类型也是onPostExecute的参数类型
    1. 从例子上我们能看到有几个重写的方法
    • onPreExecute 主线程,初始化阶段,可以做一些开启弹窗等操作
    • doInBackground 子线程,耗时操作执行的方法
    • onProgressUpdate 主线程,更新下载进度的方法,需要在doInBackground 中调用publishProgress才会执行
    • onPostExecute 主线程,结束阶段,可以执行关闭弹窗的等操作

    ok,了解这些之后,我们开始往里走走

    进入AsyncTask的构造函数中
      mWorker = new WorkerRunnable<Params, Result>() {
                public Result call() throws Exception {
                    mTaskInvoked.set(true);
                    Result result = null;
                    try {
                        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                        //noinspection unchecked
                        result = doInBackground(mParams);
                        Binder.flushPendingCommands();
                    } catch (Throwable tr) {
                        mCancelled.set(true);
                        throw tr;
                    } finally {
                        postResult(result);
                    }
                    return result;
                }
            };
    
            mFuture = new FutureTask<Result>(mWorker) {
                @Override
                protected void done() {
                    try {
                        postResultIfNotInvoked(get());
                    } catch (InterruptedException e) {
                        android.util.Log.w(LOG_TAG, e);
                    } catch (ExecutionException e) {
                        throw new RuntimeException("An error occurred while executing doInBackground()",
                                e.getCause());
                    } catch (CancellationException e) {
                        postResultIfNotInvoked(null);
                    }
                }
            };
        }
    

    在构造函数中创建了一个callable对象和futureTask对象,我们看到在mWork对象中的call方法中调用了doInBackground方法,是不是就是这个方法的入口,先暂存一下

    进入execute中
     public final AsyncTask<Params, Progress, Result> execute(Params... params) {
            return executeOnExecutor(sDefaultExecutor, params);
        }
    

    没什么东西,继续

     @MainThread
        public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
                Params... params) {
            if (mStatus != Status.PENDING) {
                switch (mStatus) {
                    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;
            exec.execute(mFuture);
    
            return this;
        }
    

    这里我们能发现Asynctask只能提交一次execute,否则会报错
    这个方法中调用了onPreExecute() ,所以该方法是第一个执行且还是处于主线程中,
    exec是什么?我们在之前的构造函数中会找到是SerialExecutor

    private static class SerialExecutor implements Executor {
            final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
            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);
                }
            }
        }
    

    在使用默认线程池时,内部使用一个双端队列来存储任务,且只能在一个任务执行完成之后才会重新调用scheduleNext()来执行下一个任务。
    再看下THREAD_POOL_EXECUTOR是什么

    static {
            ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                    CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                    sPoolWorkQueue, sThreadFactory);
            threadPoolExecutor.allowCoreThreadTimeOut(true);
            THREAD_POOL_EXECUTOR = threadPoolExecutor;
        }
    
      private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
     private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
     private static final int KEEP_ALIVE_SECONDS = 30;
    

    THREAD_POOL_EXECUTOR这个其实是一个线程池来执行任务。

    由此发现Asynctask虽然内部维护了一个多任务的线程池,但实际上还是相当于单线程的执行
    我们发现在executeOnExecutor方法中可以传入自定义的的线程池。

     val executor = ThreadPoolExecutor(10,20,10,TimeUnit.SECONDS,LinkedBlockingQueue<Runnable>())
    mAsyncTask.executeOnExecutor(executor)
    

    这样就能达到同时执行多个任务的目的。
    继续往下。在上面的 r 其实就是构造future时传入的worker对象,由此我们进入我们上文的call()方法中,开始执行doInBackground(),果然是在这里进行调用
    我们回到之前的方法

     mWorker = new WorkerRunnable<Params, Result>() {
                public Result call() throws Exception {
                    mTaskInvoked.set(true);
                    Result result = null;
                    try {
                        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                        //noinspection unchecked
                        result = doInBackground(mParams);
                        Binder.flushPendingCommands();
                    } catch (Throwable tr) {
                        mCancelled.set(true);
                        throw tr;
                    } finally {
                        postResult(result);
                    }
                    return result;
                }
            };
    

    直接到postResult方法中

     private Result postResult(Result result) {
            @SuppressWarnings("unchecked")
            Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                    new AsyncTaskResult<Result>(this, result));
            message.sendToTarget();
            return result;
        }
    

    找到handler的handlemessage方法

    private static class InternalHandler extends Handler {
            public InternalHandler(Looper looper) {
                super(looper);
            }
    
            @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
            @Override
            public void handleMessage(Message msg) {
                AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
                switch (msg.what) {
                    case MESSAGE_POST_RESULT:
                        // There is only one result
                        result.mTask.finish(result.mData[0]);
                        break;
                    case MESSAGE_POST_PROGRESS:
                        result.mTask.onProgressUpdate(result.mData);
                        break;
                }
            }
        }
    

    我们能看到在AsyncTask中通过handler将消息发送到主线程进行线程切换

     private void finish(Result result) {
            if (isCancelled()) {
                onCancelled(result);
            } else {
                onPostExecute(result);
            }
            mStatus = Status.FINISHED;
        }
    

    在finish方法中判断是否是cancel状态,不是则调用onPostExecute方法。我们记得更新进度需要在doInBackground中调用publishProgress,来看下具体是怎么更新的

    protected final void publishProgress(Progress... values) {
            if (!isCancelled()) {
                getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                        new AsyncTaskResult<Progress>(this, values)).sendToTarget();
            }
        }
    

    通过handler来进行发送,在handleMessage中再调用onProgressUpdate方法。
    至此所有方法的调用已全部出现

    总结一下:
    AsyncTask 在其内部通过handler和Thread进行线程的切换
    在默认情况下Asynctask内部维护了具体大小的一个线程池,但是实际上是单线程执行。(在3.0以前,最大支持128个线程的并发,10个任务的等待。在3.0以后,无论有多少任务,都会在其内部单线程执行),但可以传入自定义的线程池来完成多任务并行

    https://blog.csdn.net/guolin_blog/article/details/11711405

    相关文章

      网友评论

          本文标题:Android AsyncTask

          本文链接:https://www.haomeiwen.com/subject/obnroctx.html