大喵爱吃鱼的博客

编程在于积累,积累在于点滴

Andorid异步处理之AsyncTask

Andorid异步处理之AsyncTask
         上一节我们讲了Handler的异步处理机制,利用线程和Handler的收发消息来实现异步处理,十分的灵活和方便,而今天我们要讲的是google封装的专门用来处理异步的AysncTask框架
 AsyncTask是一个轻量级的异步框架,根本原因其实和Handler机制的原理是一样的,主要是为了提供异步机制来解决无法在子线程中更新UI问题。而AsyncTask中封装了线程池和Handler,省去了频繁创建和回收线程的消耗以及操作Handler机制的相对复杂问题。更加轻便简洁。
        在讲解源码以前,首先让我们看看如何使用过AsyncTask。

一、AsyncTask使用
        1、继承AsyncTask
           AsyncTask是一个抽象类,因此这里我们需要继承AyncTask抽象类 public abstract class AsyncTask<Params, Progress, Result>,并实现唯一的抽象方法doInBackground()。具体如下:

class MyAsyncTask extends AsyncTask<String,Integer,String>
{
    @Override
    protected void onPreExecute() {
        super.onPreExecute();
        tv_name.setText("即将开始");
    }

    @Override
    protected void onPostExecute(String aVoid) {
        super.onPostExecute(aVoid);
        tv_name.setText(aVoid);
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
        Log.d("yy",values[0].intValue()+"");
        tv_name.setText("正在进行"+values[0].intValue());
    }

    @Override
    protected void onCancelled(String string) {
        super.onCancelled(string);
    }

    @Override
    protected void onCancelled() {
        super.onCancelled();
    }

    @Override
    protected String doInBackground(String... strings) {
        int i = 5;
        while(i>0)
        {
            i--;
            publishProgress(i);
        }
        return "完成";
    }
}

      这里可以看到AsyncTask抽象类中有三个泛型<Params, Progress, Result>,现在再来分析这三个泛型参数:
  • Params  作为后台任务protected String doInBackground(params... strings)执行的参数类型
  • Result 作为后台任务结束后返回的参数类型,用于下表编号为3、5的方法
  • Progress 用于后台任务执行过程中的进度显示 ,用于下表中4、7方法

        接下来我们来通过一个表格说明AsyncTask常用的方法:
编号
方法
参数
作用
执行线程
1
protected void onPreExecute()
在执行后台任务钱调用,进行一些准备工作
主线程
2
protected String doInBackground(params... strings)
params
在此方法中执行我们的后台任务并在任务结束后返回Result参数,在方法中调用publishProgress(Progress Value),则会对应调用onProgressUpdate(Progress... values)
子线程
3
protected void onPostExecute(Result result)
Result
在后台任务完成后调用,并返回结果Result参数
主线程
4
protected void onProgressUpdate(Progress... values)
Progress
在后台任务执行时进行进度的更新
主线程
5
protected void onCancelled(Result result)
Result
在后台任务被取消时调用
主线程
6
protected void onCancelled()
在后台任务被取消时调用
主线程
7
protected final void publishProgress(Progress... values)
Progress
在执行后台任务时传递执行进度,会调用 onProgressUpdate(Progress... values)
子线程
这就是一个简单的AsyncTask使用,可以看到,除了doInBackground()和publishProgress()外,其他方法都是在UI线程中被调用的
在使用是需要在UI线程中实例化AsyncTask,并在UI线程中执行execute()方法。到这里呢,AsyncTask的使用我们就介绍完了,接下来开始分析源码了。

二、源码分析

       1、AsyncTask中的Handler封装
            
private static class InternalHandler extends Handler {
    public InternalHandler() {
        super(Looper.getMainLooper());
    }

    @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;
        }
    }
}
这里的InternalHandler继承了Handler,在构造方法中调用了 super(Looper.getMainLooper());由于AsyncTask的实例化和execute的执行都是在UI线程,因此这里的Handler也会是创建在主线程,自然Looper也是获得主线程的Looper。
因此看到这里我们可以大胆猜测,在我们执行异步任务的地方会调用InternalHandler发送消息,消息为MESSAGE_POST_RESULT和MESSAGE_POST_PROGRESS,然后在Handler中收到消息后对应的执行方法。


2、线程池分析
这里先简单介绍Executor框架,Executor框架主要包含任务,任务的执行。
首先分析,任务:被执行的任务需要实现Runnnable接口和callable接口。通常我们使用FurtureTask(不熟悉的自行百度)
                    任务的执行:一个实现Executor或者是继承 ExecutorService接口的自定义类,或者使用Executor已经提供了两个来ThreadPoolExecutor 和 ScheduledThreadPoolExecutor。

那么我们首先到源码找任务,也就是FurtureTask,可以看到,它在AsyncTask的构造方法中完成了实例化,具体如下

public 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);
            }
        }
    };
而在FurtureTask中传入了一个WorkRunnable,那么这个WorkRunnable又是什么呢?

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}

它是一个静态抽象类,实现了Callable接口。
好了,到这里这个传入WorkRunnable的FurtureTask就是我们上面说的执行的任务。既然是我们执行的异步任务,那么我们在doInBackground就应该这里执行,好的,那么回到WorkRunnable中的call()方法可以看到,在call方法中执行了如下方法

  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;
这里我们就可以看到执行了result = doInBackground(mParams);,然后在finally中将result传入  postResult(result);中。这里我们先不讲postResult(result),之后会详细说明。
我们已经找到了Executor的任务,那么任务的执行类在哪里呢?这就需要我们回到代码里,如下:
那么我们就需要找到这个FurtureTask在哪里被调用?
首先我们看AsyncTask的execute()方法,发现它调用了executeOnExecutor(sDefaultExecutor, params);然后再进入executeOnExecutor()方法,这个时候就可以看到,exec.execute(mFuture);,而这里的mFuture就是我们的FurtureTask,而exec则是传入的sDefaultExecutor。那么sDefaultExecutor又是什么呢?
这个sDefaultExecutor就是我们的默认任务执行者。

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

而这个SERIAL_EXECUTOR如下:、

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);
        }
    }
}
也就是说实际上是执行了SerialExecutor的execute()方法。在执行完一个线程后,后调用scheduleNext();
进入scheduleNext()会发现,这里是调用了THREAD_POOL_EXECUTOR来执行异步任务。
那么现在进入THREAD_POOL_EXECUTOR。

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

可以看到THREAD_POOL_EXECUTOR是一个ThreadPoolExecutor,也是一个任务执行的线程池。其中CORE_POOL_SIZE为可以同时运行的线程数,而MAXIMUM_POOL_SIZE为可以同时有多少线程数。
在Andorid3.0以前,AsyncTask是支持5个线程同时执行的,缓冲队列中最多可以有128个。而在Android3.0以后,改为每次只能执行1个线程,之后才可以执行第二个。



原来WorkRunnable是一个实现了Callable接口的抽象类,而这个workRunnable作为参数传入FurtureTask中,而FutureTask实现了Runnable和Furture接口。
再看SerialExecutor的execute执行的Runnable,也就是说实际执行的FutureTask,并且执行的run方法是FutureTask的run方法,而在FurtureTask的run方法中则会调用Callable接口的call方法,也就是workRunnable的call()方法。

好了,到这里整理一次,SerialExcutior是执行线程的异步类,执行的是Runnable,也就是执行的是FurtureTask,具体呢则是作为参数传入FurtureTask的WorkRunnable的call方法。现在线程池,和任务就明了了。

3、前面我们已经介绍了线程池和Handler,但是这两者又是怎么样的关系呢?接下来我们就要分析AsyncTask的execute方法()分析
       首先来看execute()方法

@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
}
需要注意这里的execute()需要在UI线程中执行,并且只能执行一次。

接下里看executeOnExecutor(sDefaultExecutor, params);    这里的sDefaultExecutor就是我们前面提到的执行任务的SerialExecutor。
继续向下看

@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;
}
到这里,我们会发现,会有一个判断if (mStatus != Status.PENDING),现在看这个Status,
public enum Status {
    /**
     * Indicates that the task has not been executed yet.
     */
    PENDING,
    /**
     * Indicates that the task is running.
     */
    RUNNING,
    /**
     * Indicates that {@link AsyncTask#onPostExecute} has finished.
     */
    FINISHED,
}
可以看到Status有三个状态:
  • PENDING 表示当前的AsyncTask没有执行过execute
  • RUNNING 表示当前的AsyncTask正在执行任务
  • FINISHED 表示任务已经执行完成
回到代码里,我们发现只有在PENDING状态时,才能执行execute,也就是在没有执行过execute()方法时才可以执行。如果任务正在执行,则Status状态为RUNNING,此时抛出new IllegalStateException("Cannot execute task: the task is already running.");如果Status为FINISHED,此时抛出new IllegalStateException("Cannot execute task:the task has already been executed  (a task can be executed only once)")。
那么现在来解决一个问题为什么AsyncTask只能执行一次execute()?
原因是执行过一次execute()并结束任务后,AsyncTask会将Status置为FINISHED。因此在下一次执行时则会抛出异常。

好的,状态判断完毕了,继续往下走。 因为接下来要执行任务了,所以将Status置为RUNNING, mStatus = Status.RUNNING;
到这里就会发现我们熟悉的方法,首先是    onPreExecute();就是在执行后台任务前我们执行准备的方法,然后    exec.execute(mFuture);,到这里就开始执行后台任务,传入的参数就是我们前面提到的FurtureTask,那么我们再回到SerialExecutor中,会发现是调用了FurtureTask的run方法,也就是调到了WorkRunnable的call方法。

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;
}
};
在call()方法中会发现result = doInBackground(mParams);,这里调用了我们的doInBackground()方法,执行我们的后台任务。执行完成后返回结果result,然后调用postResult(result);

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

这里调用了getHandler()也就是我们前面提到的InternalHandler,这里是发送了一个消息MESSAGE_POST_RESULT,message.sendToTarget();这里的Target也是我们的InternalHandler。InternalHandler接收到了消息后调用result.mTask.finish(result.mData[0]);
这里的result是AsyncTaskResult,具体如下:

@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    final Data[] mData;

    AsyncTaskResult(AsyncTask task, Data... data) {
        mTask = task;
        mData = data;
    }
}

它是一个数据封装类,用于传递我们需要的数据,并在每次发送消息时,都会传入当前的AsyncTask对象。这里的result.mTask.finish(result.mData[0]);就是调用当前AsyncTask的finish()方法,我们接着看finish()方法

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

可以看到会判断是否调用的取消,如果没有调用,则会调用onPostExecute(result);并将结果传进去。同时会将状态置为FINISHED.


如果我们调用publishProgress,则会发送给一个MESSAGE_POST_PROGRESS消息,然后调用onProgressUpdate方法,并且将进度传入。

二、优缺点
  优点:(1)简单便捷,封装性好,不需要我们去手动创建线程和Handler。
               (2)过程可控,我们可以控制任务的启动和停止,同时还可以获得任务进度
 缺点:(1)在处理多个异步操作并共同进行UI变更时,比较复杂。
             (2)在Android3.0以前,线程池中真正的工作线程只有5个,多了需要排队,Android3.0以后,则会根据cpu数目判断允许同时运行的线程数目,但是线程都是依次执行的。
             (3)一个AsyncTask的execute方法只能执行一次。

三、和Handler比较
        Handler优点:结构清晰,功能定义明确;对于多个后台任务时,简单清晰
                        缺点:在单个后台处理异步时,相对AsyncTask代码复杂一些。
















阅读更多
版权声明:本文为博主原创文章,转载请说明出处 https://blog.csdn.net/ckq5254/article/details/79955180
文章标签: AsyncTask 异步处理
所属专栏: Android从新手到进阶
上一篇Andorid异步处理之Handler消息机制分析
下一篇Android性能优化篇——内存泄漏和OOM
想对作者说点什么? 我来说一句

Android AsyncTask异步处理下载网页

2012年10月23日 700KB 下载

Redmine 管理员手册

2013年10月31日 135KB 下载

没有更多推荐了,返回首页

关闭
关闭