Android 异步处理

系统管理员 2022-05-22 06:05 160阅读 0赞

咱们都知道在Android主线程中处理耗时任务会产生ANR，所有很多耗时的任务都需要异步处理。Android里面的有四种常见的异步处理类见：Thread、HandlerThread、AsyncTask、IntentService。

# 一、Thread #

线程是执行任务的最基本的单元，当然了在Android中线程分为两大部分：主线程、子线程。Thread线程主要有以下几种状态：

*  New：实例被创建。
 *  Runnable：就绪状态。
 *  Running：线程被cpu执行调用run()函数之后 就处于运行状态。
 *  Blocked：调用join()函数、sleep()函数、wait()函数使线程处于阻塞状态。
 *  Dead：线程的run()方法运行完毕或被中断或被异常退出，线程将会到达Dead状态。

>        当需要新起一个线程来执行某个子任务时，就创建了一个线程。但是线程创建之后，不会立即进入就绪状态，因为线程的运行需要一些条件（比如内存资源、Java栈、本地方法栈都是线程私有的，所以需要为线程分配一定的内存空间），只有线程运行需要的所有条件满足了，才进入就绪状态。当线程进入就绪状态后，不代表立刻就能获取CPU执行时间，也许此时CPU正在执行其他的事情，因此它要等待。当得到CPU执行时间之后，线程便真正进入运行状态。

## 1.1、Thread实现方式 ##

实现线程有两种方式：继承Thread类、以及实现Runnable接口

### 1.1.1、继承Thread类 ###

private class YourThread extends Thread { 
    
            YourThread(String name) {
                super(name);
            }
    
            @Override
            public void run() {
                //执行耗时操作,做你想做的
            }
        }
    
        YourThread yourThread = new YourThread("我的线程");
        yourThread.start();

### 1.1.2、实现Runnable接口 ###

private class YourRunnable implements Runnable { 
            @Override
            public void run() {
                //执行耗时操作,做你想做的
            }
        }
    
        Thread yourThread = new Thread(new YourRunnable(), "我的线程");
        yourThread.start();

>        Thread两种实现方式，推荐使用实现Runnable接口的方式。因为 当继承了Thread类，则不能继承其他类，而实现Runnable接口可以，而且实现Runnable接口的线程类的多个线程，可以访问同一变量，而Thread则不能。

## 1.2、Thread 主要函数介绍 ##

/** * 线程运行时需要执行的代码 */
        public void run()
    
        /** * 启动线程 */
        public synchronized void start()
    
        /** * 线程休眠，交出CPU，让CPU去执行其他的任务，然后线程进入阻塞状态，sleep方法不会释放同步锁 * * @param millis 休眠时间，单位毫秒 */
        public static void sleep(long millis) throws InterruptedException
        /** * @param millis 休眠时间，单位毫秒 * @param nanos 额外的休眠时间，单位纳秒 */
        public static void sleep(long millis, int nanos) throws InterruptedException
    
        /** * 线程让步，使当前线程交出CPU，当前线程重置为就绪状，然后又通过和其他线程公平竞争来看谁先执行。yield方法不会释放锁 */
        public static native void yield()
    
        /** * 等待线程终止，再继续执行。直白的说 就是发起该子线程的线程 只有等待该子线程运行结束才能继续往下运行 */
        public final void join() throws InterruptedException
        /** * @param millis 等待时间，单位毫秒 */
        public final void join(long millis) throws InterruptedException
        /** * @param millis 等待时间，单位毫秒 * @param nanos 额外等待时间，单位纳秒 */
        public final void join(long millis, int nanos) throws InterruptedException
    
        /** * 中断线程，我们通过interrupt方法和isInterrupted()方法来停止正在运行的线程，注意只能中断已经处于阻塞的线程 */
        public void interrupt()
    
        /** * 获取当前线程id */
        public long getId()
    
        /** * 设置获取当前线程的名字 */
        public final void setName(String name)
        public final String getName()
    
        /** * 设置获取当前线程优先级 */
        public final void setPriority(int newPriority)
        public final int getPriority()
    
        /** * 设置和判断是否是守护线程 setDaemon()函数一点要在start()函数之前调用 */
        public final void setDaemon(boolean on)
        public final boolean isDaemon()
    
        /** * 获取当前线程 */
        public static native Thread currentThread()

### 1.2.1、sleep(),wait(),yield(),join()函数的区别。 ###

*  sleep()：在指定时间内让当前正在执行的线程暂停执行，可以执行其他的任务，但不会释放“锁标志”。
 *  wait()：java.lang.Object类里面提供的方法，暂停执行，wait方法释放了“锁标志”，使得其他线程可以使用同步控制块或者方法。wait之后需要调用notify和notifyAll来通知往下执行。  
    
    
    > wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用。
 *  yield()：当前线程让步，当前线程又重新进入就绪状态。又和其他线程公平竞争看谁先执行。(注意哦：并不是完完全全的让给其他线程了，而是又重新竞争哦，有可能还是自己执行也有可能是其他的线程执行)。
 *  join()：等待线程结束。

### 1.2.2、用户线程和守护线程 ###

Java里面将线程分为User Thread(用户线程)和Daemon Thread(守护线程)两种。Daemon Thread是运行在后台的线程。我们Android里面的MainThread就是User Thread而不是Daemon Thread。Daemon Thread一般用来给User Thread提供服务。

> 调用setDaemon()函数去设置是否是守护线程的时候，该函数一点要在start()函数之前调用。否则无效。

## 1.3、如何优雅的终止Thread ##

JDK里面Thread提供了一个stop()方法，但是stop()方法是一个被废弃的方法。为什么stop()方法被废弃而不被使用呢？因为stop()方法太过于暴力，会强行把执行一半的线程终止。这样会就不会保证线程的资源正确释放，通常是没有给与线程完成资源释放工作的机会，因此会导致程序工作在不确定的状态下。既然stop()方法不让用了，那咱们还有哪些方法来终止Thread呢。 \#\#\# 1.3.1、监视某个退出标志位        简单地设置一个标志位，需要配合while()循环使用，并通过设置这个标志来控制循环是否退出。

public class YourThread extends Thread { 
    
            public volatile boolean mExit = false;
    
            @Override
            public void run() {
                super.run();
                while (!mExit) {
                    System.out.println("I'm running");
                }
            }
        }

\#\#\# 1.3.2、使用interrupt方法终止线程        调用interrupt()方法之后interrupted()结果为true，最后采用抛异常的方式来终止线程，代码如下：

public class YourThread extends Thread { 
    
            @Override
            public void run() {
                try {
                    while (true) {
                        if (interrupted()) {
                            throw new InterruptedException();
                        }
                        System.out.println("I'm running");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
            }
        }

# 二、HandlerThread #

HandlerThread是实现了Lopper的线程(归根到底他还是一个线程)。为什么需要HandlerThread这东西呢，因为Android中为了同时完成多个任务，经常会在应用程序当中创建多个线程。这个时候为了让多个线程之间能够方便的通信，这个时候我们通常会使用Handler实现线程间的通信。但是Handler对应的线程必须包含Looper(Android主线程默认已经包含Looper了)。默认线程是没有Looper的。不过我们可以自己去创建Looper，为线程创建Looper的方法如下：在线程run()方法当中先调用Looper.prepare()初始化Looper,然后再run()方法最后调用Looper.loop()启动循环。那，现在为了方便大家不用我们每次都去写这些Looper的创建。Android API就给我们提供了HandlerThread。

> 记住，想通过Handler把消息发送到那个线程里面去，对应的线程必须包含Looper。

## 2.1、HandlerThread使用 ##

HandlerThread使用步骤：

*  创建HandlerThread线程。
 *  启动HandlerThread线程。
 *  创建Handler对象，Lopper必须是HandlerThread里面的Looper。(Hander用于发送消息)
 *  用完之后记得退出循环，要不然HandlerThread线程一直占内存。

ublic class HandlerThreadActivity extends MobileBaseActivity { 
    
        private HandlerThread mHandlerThread;
        private Handler       mHandler;
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            //创建一个线程,线程名字：handler-thread
            mHandlerThread = new HandlerThread("handler-thread");
            //开启一个线程
            mHandlerThread.start();
            mHandler = new Handler(mHandlerThread.getLooper()) {
                @Override
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    //这个方法是运行在 handler-thread 线程中的 ，可以执行耗时操作
                    Log.d("handler ", "消息： " + msg.what + " 线程： " + Thread.currentThread().getName());
                }
            };
            //在主线程给handler发送消息
            mHandler.sendEmptyMessage(1);
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            //释放资源
            mHandlerThread.quit();
        }
    }

> 千万要记得HandlerThread用完之后要调用quit()方法退出循环。

## 2.2、HandlerThread源码实现过程 ##

上面对HandlerThread的使用做了一个很简单的介绍，接下来咱们就来具体的看下HandlerThread的源码。对于HandlerThread得明确他是一个带Looper的线程。

HandlerThread源文件也非常的简单，如下

public class HandlerThread extends Thread { 
    
        ...
    
        /** * 线程开始loop之前的回调 */
        protected void onLooperPrepared() {
        }
    
        @Override
        public void run() {
            mTid = Process.myTid();
            Looper.prepare();
            synchronized (this) {
                mLooper = Looper.myLooper();
                notifyAll();
            }
            Process.setThreadPriority(mPriority);
            onLooperPrepared();
            Looper.loop();
            mTid = -1;
        }
    
        /** * 获取Looper对象 */
        public Looper getLooper() {
            if (!isAlive()) {
                return null;
            }
    
            // If the thread has been started, wait until the looper has been created.
            synchronized (this) {
                while (isAlive() && mLooper == null) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                    }
                }
            }
            return mLooper;
        }
    
        /** * 退出looper循环() */
        public boolean quit() {
            Looper looper = getLooper();
            if (looper != null) {
                looper.quit();
                return true;
            }
            return false;
        }
    
        /** * 和quit()方法一样，只不过这个更加的安全 */
        public boolean quitSafely() {
            Looper looper = getLooper();
            if (looper != null) {
                looper.quitSafely();
                return true;
            }
            return false;
        }
    
        ...
    
    }

这里我们主要关注run()方法里面的内容，其他的方法都很简单，大家肯定一看就懂。run()方法里面开始的时候调用了Looper.prepare();，run()方法快结束的时候调用了Looper.loop();这样就让HandlerThread循环起来了。run()方法里面大家有发现notifyAll();的调用把。这干啥的呀。来我们先看getLooper()方法了，是不是在getLopper()方法里面mLooper = null的时候调用了wait()。当mLooper=null的时候getLopper()就一直等在这里了，等mLooper不为null的时候才返回mLooper。notifyAll()就是run()方法里面获取到了mLooper之后通知wait()不用等了，可以去获取了。

# 三、AsyncTask #

AsyncTask是Android提供的另一个异步处理的工具类，它对Thread和Handler进行了封装，方便我们在后台线程中执行操作，然后将结果发送给主线程，从而在主线程中进行UI更新等操作。使用AsyncTask的时候，我们无需关注Thread和Handler，AsyncTask内部会对其进行管理，这样我们就只需要关注于我们的业务逻辑即可。

AsyncTask有四个重要的回调方法，分别是：onPreExecute、doInBackground, onProgressUpdate 和 onPostExecute。这四个方法会在AsyncTask的不同时期进行自动调用，我们只需要实现这几个方法的内部逻辑即可。这四个方法的一些参数和返回值都是基于泛型的，而且泛型的类型还不一样，所以在AsyncTask的使用中会遇到三种泛型参数：Params, Progress 和 Result。

> 四个重要方法介绍

*  onPreExecute()：运行在UI线程，后台任务即将开始。
 *  doInBackground()：运行在单独的工作线程中，处理后台任务逻辑。
 *  onProgressUpdate()：运行在UI线程，一般用于回传任务处理的进度。
 *  onPostExecute()：运行在UI线程，后台任务执行完毕。

> 三种泛型介绍

*  Params：开始异步任务执行时传入的参数类型。
 *  Progress：异步任务执行过程中，返回下载进度值的类型。
 *  Result：异步任务执行完成后，返回的结果类型。

## 3.1、AsyncTask使用 ##

AsyncTask使用也非常简单，主要的关注点都在我们的业务逻辑上。比如我们来实现一个文件下载的任务。伪代码如下：

public class AsyncTaskActivity extends MobileBaseActivity { 
    
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            String[] urls = {
       "http://blog.csdn.net/iispring/article/details/47115879"};
    
            DownloadTask downloadTask = new DownloadTask();
            //开始执行任务
            downloadTask.execute(urls);
        }
    
        /** * Params - > String：文件url * Progress - > Float 文件下载进度 * Result - > Long 下载的文件大小 */
        private class DownloadTask extends AsyncTask<String, Float, Long> { 
    
            @Override
            protected void onPreExecute() {
                super.onPreExecute();
                //TODO:UI线程执行，开始执行任务的回调
            }
    
            @Override
            protected Long doInBackground(String... strings) {
                //TODO:1. 从参数里面获取到文件的下载地址。2. while循环读取网络文件信息，并且实时调用publishProgress告诉下载进度
                downloadTask(strings[0]);
                return null;
            }
    
            @Override
            protected void onProgressUpdate(Float... values) {
                super.onProgressUpdate(values);
                //TODO:下载进度回调上来
            }
    
            @Override
            protected void onPostExecute(Long aLong) {
                super.onPostExecute(aLong);
                //TODO:任务执行完成
            }
    
            private void downloadTask(String path) {
                //模拟耗时操作
                int count = 0;
                try {
                    while (count < 100) {
                        count++;
                        Thread.sleep(3 * 1000);
                        publishProgress((float) count);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

## 3.2、AsyncTask源码实现过程 ##

AsyncTask源代码的分析。

先从构造函数开始，

> 构造函数

public AsyncTask(@Nullable Looper callbackLooper) {
            mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
                ? getMainHandler()
                : new Handler(callbackLooper);
    
            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);
                    }
                }
            };
        }

就是初始化了三个变量，mHandler、mWorker、mFuture。mHandler是用来post消息的，把onProgressUpdate()和onPostExecute()post到主线程里面去执行。

接着，如果AsyncTask想执行任务，会调用execute()函数，我们直接看下execute()函数。

> execute()

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

execute()函数直接调用了executeOnExecutor()函数。注意第一个参数是sDefaultExecutor。他是一个static修饰变量，是所有AsyncTask共有的。

> sDefaultExecutor

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

分析代码我们发现sDefaultExecutor会把所有的任务依次加入到线程池中，而且保证了先进来的任务加入线程池，执行完一个任务就加入一个线程池。其中线程池THREAD\_POOL\_EXECUTOR也是一个static变量。

> executeOnExecutor()

@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只能excute一次。在接着调用onPreExecute(); 回调告诉任务准备开始了。最后exec.execute(mFuture);把mFuture加入到sDefaultExecutor里面去。mFuture在构造函数里面已经声明了。从构造函数得知会执行mWorker变量的call()函数，call()函数执行完之后会执行mFuture对象的done()函数。

> 先执行mWorker的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;
                }
            };

> mWorker的call()函数执行完之后执行mFuture的done()函数

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

mWorker的call()函数里面调用了doInBackground()吧，并且是在后台线程中执行的。call()函数的最后调用了postResult(result);把结果回调给主线程。

我们看下postResult()是怎么回调到主线程的。

> postResult()函数

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

很熟悉把，getHandler()对应的是哪个线程，就去哪个线程执行了。

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

其中两种消息类型MESSAGE\_POST\_RESULT、MESSAGE\_POST\_PROGRESS一个用来回调执行结果的，一个用来回调执行进度的。一个对应onPostExecute()的回调，一个对应onProgressUpdate()的回调。当然了如果你想触发onProgressUpdate()执行进度的回调，你的自己在doInBackground()里面主动的去调用publishProgress()函数。

AsyncTask源码的分析过程关键是抓住onPreExecute、doInBackground, onProgressUpdate 和 onPostExecute函数的调用位置和所处的线程。AsyncTask的简单分析就到这里有疑问也可以留言。

# 四、IntentService #

IntentService 是继承自 Service 并处理异步任务的一个类。IntentServicer最大的特点是用完即走。处理玩异步任务IntentService会自动结束。

## 4.1、IntentService的使用 ##

IntentService有一个非常重要的方法onHandleIntent(),onHandleIntent()当某个请求需要处理时，这个方法会在工作者线程被调用，一次仅仅会有一个请求被处理。所以我们在onHandleIntent()函数里面处理我们的异步逻辑。

> 写一个非常的下载例子

public class IntentServiceActivity extends MobileBaseActivity { 
    
        public final static String ACTION_TYPE_THREAD = "action.type.thread";
    
        @Override
        protected void onCreate(@Nullable Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            // 启动异步任务
            DownloadIntentService.startDownload(IntentServiceActivity.this, "image path");
        }
    
        static class DownloadIntentService extends IntentService {
    
            public static final String EXTRA_DOWNLOAD_IMAGE = "com.tuacy.convenientinputedit.DOWNLOAD_IMAGE";
    
            public DownloadIntentService() {
                super("DownloadIntentService");
            }
    
            public static void startDownload(Context context, String path) {
                Intent intent = new Intent(context, DownloadIntentService.class);
                intent.putExtra(EXTRA_DOWNLOAD_IMAGE, path);
                context.startService(intent);
            }
    
            @Override
            protected void onHandleIntent(Intent intent) {
                if (intent != null) {
                    String path = intent.getStringExtra(EXTRA_DOWNLOAD_IMAGE);
                    downloadTask(path);
                }
            }
    
            private void downloadTask(String path) {
                //模拟耗时操作
                try {
                    Thread.sleep(3 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //利用广播通知主界面更新
                Intent intent = new Intent(IntentServiceActivity.ACTION_TYPE_THREAD);
                intent.putExtra(EXTRA_DOWNLOAD_IMAGE, path);
                sendBroadcast(intent);
            }
    
            @Override
            public void onCreate() {
                super.onCreate();
            }
    
            @Override
            public void onDestroy() {
                super.onDestroy();
            }
        }
    
    }

> IntentService的启动方式采用startService()。

## 4.2、IntentService源码分析 ##

IntentService的源码也非常的简单。我们做一个简单的分析。

public class IntentService extends Service { 
    
        private volatile ServiceHandler mServiceHandler;
    
        private final class ServiceHandler extends Handler { 
            public ServiceHandler(Looper looper) {
                super(looper);
            }
    
            @Override
            public void handleMessage(Message msg) {
                onHandleIntent((Intent)msg.obj);
                stopSelf(msg.arg1);
            }
        }
    
        @Override
        public void onCreate() {
    
            super.onCreate();
            HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
            thread.start();
    
            mServiceLooper = thread.getLooper();
            mServiceHandler = new ServiceHandler(mServiceLooper);
        }
    
        @Override
        public void onStart(@Nullable Intent intent, int startId) {
            Message msg = mServiceHandler.obtainMessage();
            msg.arg1 = startId;
            msg.obj = intent;
            mServiceHandler.sendMessage(msg);
        }
    
        @Override
        public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
            onStart(intent, startId);
            return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
        }
    
        ...
    }

通过startService()方式启动Service之后会先回调onCreate()方法，然后回调onStart()或者onStartCommand()方法(android2.0以下调用onStart(),android2.0之上调用onStartCommand()方法)。onCreate()方法里面启动了一个HandlerThread线程。并且mServiceHandler绑定到HandlerThread线程上去了。后面通过mServiceHandler发送的消息都会在这个HandlerThread线程里面执行。onStart()的回调函数马上就发送了一个消息出去，消息到ServiceHandler类的handleMessage()里面处理。调用onHandleIntent()函数，之后调用stopSelf()整个IntentService也就自动停止了。

--------------------

以上就是对Android里面的异步处理做了一个简单的总结。