Android异步机制的几种实现方式剖析

今天来谈一谈android中异步处理机制，众所周知在android中由于UI主线程是不安全的，因此不能直接在子线程中操作UI，一般我们会用到异步机制来解决这种问题，下面会介绍两种常用的异步机制Thread+Handler与Async Task机制；

一、Thread+Handler

提起Thread'很多人都不会陌生，做过Android手机开发的人都知道，手机UI是一个单独的线程在运行，并且该线程最好不会因为用户的操作而阻塞。换句话说，如果用户进行的操作需要耗时几十秒甚至几十分钟，那么在这段时间内占用UI线程是一个非常不明智的做法。它会阻塞掉UI线程，导致手机不再显示或者接受用户新的操作，给用户一种死机的感觉，因此我们开辟出子线程用来执行耗时操作。我们可以通过Thread+Handler来实现具体UI与子线程的协同；

下面是常用的handler：

private Handler mHandler = new Handler() {  
        public void handleMessage (Message msg) {//此方法在ui线程运行  
            switch(msg.what) {  
            case MSG_SUCCESS:  
                
                break;  
  
            case MSG_FAILURE:  
                break； 
            }  
        }  
    };  

我们通过thread中的发送消息操作将消息传递给handler

Runnable runnable = new Runnable() {  
          
        @Override  
        public void run() {//run()在新的线程中运行 

<span style="white-space:pre">		</span>//执行耗时操作 
           
            mHandler.obtainMessage(MSG_SUCCESS,bm).sendToTarget();//获取图片成功，向ui线程发送MSG_SUCCESS标识和bitmap对象  
  

            
        }  
    };  
      
}  

由以上步骤我们便完成了一个最基本的异步机制，但是这种方式内部到底是如何传递消息的呢？就让我们在源码中找到它们的身影。

在上述代码中我们发现了最终是把信息通过sendToTarget()方法发送了，我们来看他的源码：

/** 
   * Sends this Message to the Handler specified by {@link #getTarget}. 
   * Throws a null pointer exception if this field has not been set. 
   */  
  public void sendToTarget() {  
     <span style="background-color:#ff0000"> target.sendMessage(this);</span>  
  }  

我们发现最终还是调用了sendMessage方法，继续看它的源码：

/** 
     * Pushes a message onto the end of the message queue after all pending messages 
     * before the current time. It will be received in {@link #handleMessage}, 
     * in the thread attached to this handler. 
     *   
     * @return Returns true if the message was successfully placed in to the  
     *         message queue.  Returns false on failure, usually because the 
     *         looper processing the message queue is exiting. 
     */  
    public final boolean sendMessage(Message msg)  
    {  
        return sendMessageDelayed(msg, 0);  
    } 

它是调用了 sendMessageDelayed方法，下面我摘出了几个片段我们分析一下：

public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
    if (delayMillis < 0) {
        delayMillis = 0;
    }
    return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}

调用sendMessageAtTime()；

public boolean sendMessageAtTime(Message msg, long uptimeMillis)  
{  
    boolean sent = false;  
    MessageQueue queue = mQueue;  
    if (queue != null) {  
        msg.target = this;  
        sent = queue.enqueueMessage(msg, uptimeMillis);  
    }  
    else {  
        RuntimeException e = new RuntimeException(  
            this + " sendMessageAtTime() called with no mQueue");  
        Log.w("Looper", e.getMessage(), e);  
    }  
    return sent;  
}  

sendMessageAtTime()方法接收两个参数，其中msg参数就是我们发送的Message对象，而uptimeMillis参数则表示发送消息的时间，它的值等于自系统开机到当前时间的毫秒数再加上延迟时间，如果你调用的不是sendMessageDelayed()方法，延迟时间就为0，然后将这两个参数都传递到MessageQueue的enqueueMessage()方法中。这个MessageQueue又是什么东西呢？其实从名字上就可以看出了，它是一个消息队列，用于将所有收到的消息以队列的形式进行排列，并提供入队和出队的方法。这个类是在Looper的构造函数中创建的，因此一个Looper也就对应了一个MessageQueue。那么enqueueMessage()就是所谓的入队操作，入队已经完成接下来就需要进行出队获取消息。先看如下代码段：

public static final void loop() {  
    Looper me = myLooper();  
    MessageQueue queue = me.mQueue;  
    while (true) {  
        Message msg = queue.next(); // might block  
        if (msg != null) {  
            if (msg.target == null) {  
                return;  
            }  
            if (me.mLogging!= null) me.mLogging.println(  
                    ">>>>> Dispatching to " + msg.target + " "  
                    + msg.callback + ": " + msg.what  
                    );  
            msg.target.dispatchMessage(msg);  
            if (me.mLogging!= null) me.mLogging.println(  
                    "<<<<< Finished to    " + msg.target + " "  
                    + msg.callback);  
            msg.recycle();  
        }  
    }  
}  

在while的死循环里不断地去进行出队操作，出队的方法就是next（）；出队后消息去了哪里呢？我们发现他调用了msg.target的dispatchMessage()，这里msg.targe就是handler，也就是说它调用的handler的dispatchMessage()

public void dispatchMessage(Message msg) {  
    if (msg.callback != null) {  
        handleCallback(msg);  
    } else {  
        if (mCallback != null) {  
            if (mCallback.handleMessage(msg)) {  
                return;  
            }  
        }  
        handleMessage(msg);  
    }  
} 

我们发现了一个熟悉的方法handleMessage（），这不正是我们写在handler中的方法吗？并且这里还传递了message过去，到这里一切豁然开朗，经过一圈，消息最终由子线程传递到了handler的handleMessage（）中进行UI处理。

二、Async Task

Android从很早就引入了一个AsyncTask类，我们利用它可以非常灵活方便地从子线程切换到UI线程，由于Async Task是一个抽象类，因此我们必须去用子类去继承他才能去使用，在继承时我们可以为AsyncTask类指定三个泛型参数，这三个参数的用途如下：

1. Params

在执行AsyncTask时需要传入的参数，可用于在后台任务中使用。

2. Progress

后台任务执行时，如果需要在界面上显示当前的进度，则使用这里指定的泛型作为进度单位。

3. Result

当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型。

在子类中我们需要重写以下几个常用的方法来执行相应操作：

1. onPreExecute()：

在后台任务开始执行之前调用，我们可以用来进行控件的初始化操作。

2. doInBackground(Params...)

这个方法就是我们执行耗时操作的地方，完毕后返回子类中的第三个参数类型，若为void则不进行返回。并且在此方法中是不可以进行UI操作的，如果需要更新UI元素，比如说反馈当前任务的执行进度，可以调用publishProgress(Progress...)方法来完成。

3. onProgressUpdate(Progress...)

当在doInBackground(Params...)中调用了publishProgress(Progress...)方法后，这个方法就很快会被调用，方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行相应的更新。

4. onPostExecute(Result)

当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些UI操作，比如说提醒任务执行的结果，以及关闭掉进度条对话框等。

package com.example.asynctask;  
import android.os.AsyncTask;  
import android.widget.ProgressBar;  
import android.widget.TextView;  
  
/**  
 * 生成该类的对象，并调用execute方法之后  
 * 首先执行的是onProExecute方法  
 * 其次执行doInBackgroup方法  
 *  
 */  
public class ProgressBarAsyncTask extends AsyncTask<Integer, Integer, String> {  
  
    private TextView textView;  
    private ProgressBar progressBar;  
      
      
    public ProgressBarAsyncTask(TextView textView, ProgressBar progressBar) {  
        super();  
        this.textView = textView;  
        this.progressBar = progressBar;  
    }  
  
  
    /**  
     * 这里的Integer参数对应AsyncTask中的第一个参数   
     * 这里的String返回值对应AsyncTask的第三个参数  
     * 该方法并不运行在UI线程当中，主要用于异步操作，所有在该方法中不能对UI当中的空间进行设置和修改  
     * 但是可以调用publishProgress方法触发onProgressUpdate对UI进行操作  
     */  
    @Override  
    protected String doInBackground(Integer... params) {  
        NetOperator netOperator = new NetOperator();  
        int i = 0;  
        for (i = 10; i <= 100; i+=10) {  
            netOperator.operator();  
            publishProgress(i);  
        }  
        return i + params[0].intValue() + "";  
    }  
  
  
    /**  
     * 这里的String参数对应AsyncTask中的第三个参数（也就是接收doInBackground的返回值）  
     * 在doInBackground方法执行结束之后在运行，并且运行在UI线程当中 可以对UI空间进行设置  
     */  
    @Override  
    protected void onPostExecute(String result) {  
        textView.setText("异步操作执行结束" + result);  
    }  
  
  
    //该方法运行在UI线程当中,并且运行在UI线程当中 可以对UI空间进行设置  
    @Override  
    protected void onPreExecute() {  
        textView.setText("开始执行异步线程");  
    }  
  
  
    /**  
     * 这里的Intege参数对应AsyncTask中的第二个参数  
     * 在doInBackground方法当中，，每次调用publishProgress方法都会触发onProgressUpdate执行  
     * onProgressUpdate是在UI线程中执行，所有可以对UI空间进行操作  
     */  
    @Override  
    protected void onProgressUpdate(Integer... values) {  
        int vlaue = values[0];  
        progressBar.setProgress(vlaue);  
    }  
  
      
      
      
  
}  

在调用子类时我们只需这样：

new ProgressBarAsyncTask().execute();

到这里AsyncTask的使用就完成了，下面我们对AsyncTask进行分析；

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

由上面可以知道execute调用了executeOnExecutor()方法，我们来看executeOnExecutor()方法

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

发现了什么，我们找到了子类中的onPreExecute这个方法，这也就是说此方法第一个运行；

在看如下代码：

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

因此上面二者是等同的，在  exec.execute(mFuture); 中也就相当于SerialExecutor类中的execute()，我们看它的源码：

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

我们发现了其中的run方法是执行的部分，在看run方法：

void innerRun() {  
    if (!compareAndSetState(READY, RUNNING))  
        return;  
    runner = Thread.currentThread();  
    if (getState() == RUNNING) { // recheck after setting thread  
        V result;  
        try {  
            result = callable.call();  
        } catch (Throwable ex) {  
            setException(ex);  
            return;  
        }  
        set(result);  
    } else {  
        releaseShared(0); // cancel  
    }  
}  

再找主要的执行函数call方法：

public Result call() throws Exception {  
    mTaskInvoked.set(true);  
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
    return postResult(doInBackground(mParams));  
} 

仔细看我们发现了熟悉的方法doInBackground()方法，而此时我们还是处于子线程当中，这也是doInBackground()方法能执行耗时操作的原因，我们发现最终的结果传给了postResult方法，我们来看它：

private Result postResult(Result result) {  
    Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,  
            new AsyncTaskResult<Result>(this, result));  
    message.sendToTarget();  
    return result;  
}  

到这里你发现了什么，又回到了我们熟悉的handler消息处理机制，那我们看看他的handler源码：

private static class InternalHandler extends Handler {  
    @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;  
        }  
    }  
}

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

发现了什么，这里进行调用了onPregressUpdate方法和onPostExecute方法进行UI的操作，到这里我们理解了AsyncTask的内部机制。

三、二者的差异在什么地方

有些人会问这两种实现方式怎么灵活运用，什么地方改用哪一种呢，其实二者还是有且别的：

AsyncTask 提供了像onPreExecute, onProgressUpdate这类的快速调用方法，可以被UI线程方便的调用，Thread没有。

AsyncTask 不能重复运行， 一旦执行过了，你需要下次需要时重新创建调用。 thread 可以创建成在队列中获取workitem持续调用的模式，不停地执行。

AsyncTasks的执行优先级是3.0， 默认的执行模式是一次一个任务；thread的执行则与其它线程无关。

AsyncTask 写起来较快， Thread则需要多做一些工作。

AsyncTask和Thread都不会影响你的主线程的生命周期。

精益求精方可融会贯通！