多线程--异步任务AsyncTask由浅入深探究

最新推荐文章于 2022-12-08 14:22:49 发布

verymrq

最新推荐文章于 2022-12-08 14:22:49 发布

阅读量369

点赞数

分类专栏： Android 文章标签： android asynctask 多线程异步

本文链接：https://blog.csdn.net/verymrq/article/details/53727950

版权

Android 专栏收录该内容

20 篇文章 2 订阅

订阅专栏

养成写博客的习惯，帮助大家的同时自己知识也能得到巩固，本文大多是我的读书心得，比较基础，希望能给大家一点帮助。
一般我们执行耗时任务，都是通过Thread执行，然后再通过Handler更新UI，虽然这种方式对整个过程控制很精细，但是代码相对臃肿，Android1.5后提供了工具类AsyncTask.

一般执行AsyncTask步骤为：
1、execute：通过execute（param… params）执行任务。
2、OnpreExecute：在启动任务后，首先执行OnpreExecute（），一般用于执行耗时操作前对UI进行标记的准备工作，不是必须实现。
3、doInBackground（param… params），通过传来的param执行耗时操作，在其中还可以执行publishProgress（progress… Values）来更新进度。
4、onProgressUpdate，如果在doInBackground中调用过publishProgress，此方法便会执行，来更新UI进度。
5、onPostExecute（Result result）,耗时操作结束后，通过result在此方法内改变UI。

AsyncTask是抽象类.AsyncTask定义了三种泛型类型 Params，Progress和Result。
　　Params 启动任务执行的输入参数，比如HTTP请求的URL。
　　Progress 后台任务执行的百分比。
　　Result 后台执行任务最终返回的结果，比如String。

值得一提的是：
1、异步任务实例必须在UI线程中创建；
2、execute方法也必须在UI线程中调用；
3、doInBackground方法只能执行耗时操作，不能改变UI界面；
4、一个任务实例只能执行一次任务，否则会抛出异常。

下面我们来看看AsyncTask到底是如何工作的。

首先我们来看execute，是如何启动的

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

在execute方法内调用了executeOnExecutor方法，我们接着看：

public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,Params... params) {
//通过status判断任务PENDING（闲置）、RUNNING（执行中）、FINISHED（完成）
//这也说明一个任务实例只能执行一次任务，完成后、或执行中都会抛出异常
    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();
//获取UI线程传过来的参数
    mWorker.mParams = params;
//交给线程池处理
    exec.execute(mFuture);
//返回自身，可以保持一个引用
    return this;
}

在上诉源码中，我们见到了sDefaultExecutor、mWorker、mFuture三个陌生变量。
首先sDefaultExecutor，根据名字我们都可以猜测，它是线程池，结果如我们所想：

//核心线程数
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
//最大线程数
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
//线程空闲时存留时间
private static final int KEEP_ALIVE = 1;
//线程工厂
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
    private final AtomicInteger mCount = new AtomicInteger(1);

    public Thread newThread(Runnable r) {
        return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
    }
};
//线程队列
private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);
//线程池
public static final Executor THREAD_POOL_EXECUTOR
        = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);


private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//顺序执行的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执行
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}

上诉源码说明sDefaultExecutor 只是将任务分发给了THREAD_POOL_EXECUTOR这个线程池，所以真正执行代码的地方是THREAD_POOL_EXECUTOR。关于线程池的知识本文不过多解释，愿意的可以自行百度。这里我们只需要知道是线程池执行了我们的任务。

而我们的任务是哪里来的呢？
这就要看我们的第二个变量mFuture了。

private final FutureTask<Result> mFuture;

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

可以看到，mFuture 是一个FutureTask实例，与Runnable类似，他是个可以自行管理的异步任务。
所以sDefaultExecutor 可以将mFuture 交给线程池去执行.
mFuture 中的参数便是我们的第三个变量mWorker了。

private final WorkerRunnable<Params, Result> mWorker;
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
    Params[] mParams;
}
mWorker = new WorkerRunnable<Params, Result>() {
    public Result call() throws Exception {
        mTaskInvoked.set(true);

        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        //noinspection unchecked
        Result result = doInBackground(mParams);
        Binder.flushPendingCommands();
        return postResult(result);
    }
};

mWorker 是WorkerRunnable实例，而WorkerRunnable又实现了callable接口。
关于FutureTask和callable，若有不解的，可以参考我的另一篇博客：
多线程–callable、Future、FutureTask
终于，我们看见doInBackground方法了，出现在mWorker的call（）方法中。
mWorker由mFuture 携带被sDefaultExecutor 交由线程池处理了。

执行doInBackground后，我们看见结果由postResult()接收，通过我们对AsyncTask的了解，之后应该处理UI了，想必postResult()能看见onPostExecute方法吧。
带着我们的猜测继续往下看。

private void postResultIfNotInvoked(Result result) {
    final boolean wasTaskInvoked = mTaskInvoked.get();
    if (!wasTaskInvoked) {
        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;
}

postResult将结果传给了handler，并传入一个标识MESSAGE_POST_RESULT。
这里有一个postResultIfNotInvoked方法，这个方法在上文mFuture 重写done方法中调用，任务如果顺利执行，那么就会执行Done方法。当出现异常，postResult没有正常执行时，postResultIfNotInvoked就会执行，mTaskInvoked.get()判断结果并传给postResult执行，否则将忽略结果。

如果执行正常，就需要接着看getHandler（）方法

private static Handler getHandler() {
    synchronized (AsyncTask.class) {
        if (sHandler == null) {
            sHandler = new InternalHandler();
        }
        return sHandler;
    }
}

接着看sHandler

private static InternalHandler sHandler;
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;
        }
    }
}

如我们所料，这里使用了handler来处理UI更变，当传入的msg标识为MESSAGE_POST_RESULT时，执行了 result.mTask.finish(result.mData[0])这段代码，
而result又是AsyncTaskResult的实例，那AsyncTaskResult到底是个什么东西？
其实，他是AsyncTask的内部类，用来包装结果用的。

private static class AsyncTaskResult<Data> {
    final AsyncTask mTask;
    final Data[] mData;

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

可以看到mTask是一个AsyncTask 实例，所以我们又回到 result.mTask.finish(result.mData[0])，执行了finish方法，继续跟踪：

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

终于，我们看见onPostExecute（）方法了，通过handler执行了这段代码，改变了UI界面。
在handler里，我们还看见了一个标识：MESSAGE_POST_PROGRESS，什么时候传入过这个标识呢？大概有些同学还记得publishProgress方法可以更新进度，那我们就来看看。

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

果然，这里传入了MESSAGE_POST_PROGRESS，回头看看handler里，调用了
onProgressUpdate，也就是我们重写的显示进度的方法。
所以，我们可以重复调用publishProgress来显示进度。

好了，整个AsyncTask介绍也差不多了，他对handler、线程池、Future等的封装使我们用起来方便很多，值得好好体会。
下面是我在网上找来的简单Demo，联系上文阅读，相信可以对AsyncTask了解更加深刻。

public class NetworkActivity extends Activity{
    private TextView message;
    private Button open;
    private EditText url;

    @Override
    public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.network);
       message= (TextView) findViewById(R.id.message);
       url= (EditText) findViewById(R.id.url);
       open= (Button) findViewById(R.id.open);
       open.setOnClickListener(new View.OnClickListener() {
           public void onClick(View arg0) {
              connect();
           }
       });

    }

    private void connect() {
        PageTask task = new PageTask(this);
        task.execute(url.getText().toString());
    }


    class PageTask extends AsyncTask<String, Integer, String> {
        // 可变长的输入参数，与AsyncTask.exucute()对应
        ProgressDialog pdialog;
        public PageTask(Context context){
            pdialog = new ProgressDialog(context, 0);   
            pdialog.setButton("cancel", new DialogInterface.OnClickListener() {
             public void onClick(DialogInterface dialog, int i) {
              dialog.cancel();
             }
            });
            pdialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
             public void onCancel(DialogInterface dialog) {
              finish();
             }
            });
            pdialog.setCancelable(true);
            pdialog.setMax(100);
            pdialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
            pdialog.show();


        }
        @Override
        protected String doInBackground(String... params) {

            try{

               HttpClient client = new DefaultHttpClient();
               // params[0]代表连接的url
               HttpGet get = new HttpGet(params[0]);
               HttpResponse response = client.execute(get);
               HttpEntity entity = response.getEntity();
               long length = entity.getContentLength();
               InputStream is = entity.getContent();
               String s = null;
               if(is != null) {
                   ByteArrayOutputStream baos = new ByteArrayOutputStream();

                   byte[] buf = new byte[128];

                   int ch = -1;

                   int count = 0;

                   while((ch = is.read(buf)) != -1) {

                      baos.write(buf, 0, ch);

                      count += ch;

                      if(length > 0) {
                          // 如果知道响应的长度，调用publishProgress（）更新进度
                          publishProgress((int) ((count / (float) length) * 100));
                      }

                      // 让线程休眠100ms
                      Thread.sleep(100);
                   }
                   s = new String(baos.toByteArray());              }
               // 返回结果
               return s;
            } catch(Exception e) {
               e.printStackTrace();

            }

            return null;

        }

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

        @Override
        protected void onPostExecute(String result) {
            // 返回HTML页面的内容
            message.setText(result);
            pdialog.dismiss(); 
        }

        @Override
        protected void onPreExecute() {
            // 任务启动，可以在这里显示一个对话框，这里简单处理
            message.setText(R.string.task_started);
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            // 更新进度
              System.out.println(""+values[0]);
              message.setText(""+values[0]);
              pdialog.setProgress(values[0]);
        }
     }
}

Demo原文：AsyncTask的用法总结