异步消息处理机制

前言

关于安卓中的异步消息处理机制,主要有以下几个部分:Handler、AsyncTask、HandlerThread、IntentService

Handler

一、什么是Handler?

安卓刚启动的时候,会新开一个主线程,叫做main Thread,它就是用来处理UI的线程。但是安卓中的UI操作并不是线程安全的,也就是说,可能会有多个并发的线程同时操作UI,这样就会导致界面的错乱。所以安卓中就规定只有UI线程可以处理界面。那如果其他的非UI线程想要处理UI怎么办呢?这个时候就要用到Handler。安卓中把那些比较耗时的操作放在子线程中,而把UI操作放在主线程,子线程中的耗时操作完成以后,就通过Handler来发送一个消息给主线程,告诉主线程来更新UI。所以总结一下,Handler就是安卓中非UI线程想要更新UI时,用来发送消息给主线程的一种机制。

二、怎么使用Handler?

第一步:申明一个handler,并复写它的handleMessage方法

Handler mHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if(msg.what == 1)
                mTextView.setText("更新UI");
        }
    };

第二步:在子线程通过handler发送消息通知handler执行操作

new Thread() {
            @Override
            public void run() {
                super.run();
                //do something ...

                //子线程中通过handler发送消息给handler接收,由handler去更新TextView的值
                Message msg = Message.obtain();
                msg.what = 1;
                msg.obj = "需要发送的数据";
                mHandler.sendMessage(msg);

            }
        }.start();

使用起来很简单对不对,主要就是在子线程中使用handler.sendMessage(msg)发送一个消息给主线程,然后我们具体想要怎样操作就在handleMessage中完成。

三、Handler原理分析

作为一个高逼格的程序员,我们肯定不能止步于使用,接下来我们就来分析一下Handler的实现原理,看看它到底是怎么让子线程和主线程之间实现通信的。
在分析handler的实现原理之前,我们先来了解一下几个重要的概念:

  • MessageQueue:消息队列,用于存放所有要发送出去的消息;
  • looper:轮询器,用于取出消息队列中的消息的一个工具。

大家先有个基本概念,待会通过源码来给大家加深印象。

接下来给大家分析Handler的源码:

public Handler();
public Handler(Callback callback);
public Handler(Looper looper);
public Handler(Looper looper, Callback callback);

上面四行是handler的几个构造方法,通过它的参数我们可以看到,有两个是没有looper这个东西的,而handler没有looper就好像鱼儿没有水,所以,大家应该知道looper对于handler来说有多重要了吧。
看源码我们可以知道,这两个构造方法会调用另外一个方法:

public Handler(Callback callback, boolean async) {
        if (FIND_POTENTIAL_LEAKS) {
            final Class klass = getClass();
            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                    (klass.getModifiers() & Modifier.STATIC) == 0) {
                Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                    klass.getCanonicalName());
            }
        }

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

看到了没有,在这个方法中,我们通过Looper.myLooper()方法,拿到了该线程下的mLooper的实例对象,然后再通过这个looper对象获取了一个MessageQueue对象,所以,不管怎么样,handler一定要有looper才行。
但是有人可能会有疑问,为什么在这里我们可以拿到looper的实例呢?其实我们这里拿到的looper对象是跟随主线程一起创建好的。我们在ActivityThread.class中看一下主线程创建的时候都做了什么。

public static final void main(String[] args) {

        // -----

        Looper.prepareMainLooper();
        if (sMainThreadHandler == null) {
            sMainThreadHandler = new Handler();
        }

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Looper.loop();

       // ----
    }

首先他调用了 Looper.prepareMainLooper()方法,这个方法内部调用了prepare()方法:

private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

该方法保证了looper对象的唯一性且会调用Looper构造函数同时实例化出MessageQueue和当前thread。

public static @NonNull MessageQueue myQueue() {
        return myLooper().mQueue;
    }

private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

prepare()方法中通过ThreadLocal对象实现Looper实例与线程的绑定,即保存当前的Looper实例到ThreadLocal当中,Handler中通过Looper.myLooper()将Looper实例从ThreadLocal中取出。

public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

看到这里是不是已经一脸懵逼了,那我们来总结一下吧。

首先我们要知道每一个Handler都必须要有一个looper对象和一个用于存放消息的MessageQueue对象。那这个looper对象怎么获得就是一个关键。根据源码我们可以知道,主线程在创建的时候,会调用looper.prepare()方法,该方法会从ThreadLocal中取出一个looper实例并保存下来,然后通过该实例保存一个MessageQueue对象,因为prepare()方法只能调用一次,所以就保证了looper对象的唯一性,经过这番折腾,我们就保证了handler中既有looper对象,也有MessageQueue对象,而且还都是唯一的。

既然Handler、Looper、MessageQueue这三大要素都有了,那我们是不是就该看看发送消息的机制了。

想要发送消息,首先要有消息才行,接下来就给大家分析一下怎么把消息加入到消息队列中去。

public final boolean sendMessage(Message msg) {
        return sendMessageDelayed(msg, 0);
    }

public final boolean sendEmptyMessage(int what) {
        return sendEmptyMessageDelayed(what, 0);
    }

public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
        Message msg = Message.obtain();
        msg.what = what;
        return sendMessageDelayed(msg, delayMillis);
    }

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

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

可以看到,虽然有很多发送消息的方法,但是它们最终都调用了sendMessageAtTime()方法,然后返回了enqueueMessage(),我们来看看这个方法的源码

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

这个方法中有两个东西需要注意:

  • msg.target = this;
    • 这句话的意思是告诉我们这个消息发送的目标的是谁,是this,点进target我们可以得知这个目标就是当前的handler,也就说我们消息发送的目标就是我们的handler;
  • queue.enqueueMessage()
    -queue是MessageQueue的对象,通过queue.enqueueMessage()方法将消息存放到消息队列中去。

异步消息处理机制_第1张图片

这个图就能很好的理解消息发送的调用顺序,最终都是调用MessageQueue.enqueueMessage()方法,将消息加入消息队列中去。

消息既然已经到了消息队列中,总不能让它闲着对吧,总得有个东西把它取出来,这时候就要用到上面提到的Looper了。

public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

            // This must be in a local variable, in case a UI event sets the logger
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            try {
                msg.target.dispatchMessage(msg);
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            final long newIdent = Binder.clearCallingIdentity();
            if (ident != newIdent) {
                Log.wtf(TAG, "Thread identity changed from 0x"
                        + Long.toHexString(ident) + " to 0x"
                        + Long.toHexString(newIdent) + " while dispatching to "
                        + msg.target.getClass().getName() + " "
                        + msg.callback + " what=" + msg.what);
            }

            msg.recycleUnchecked();
        }
    }

首先先判断一下,保证looper对象不能为空,如果为空,就抛出looper没有prepare()异常。在保证了looper不为空的情况下,就在一个死循环中通过queue.next()方法不断的取出消息队列中的消息,然后通过代码msg.target.dispatchMessage(msg)让该msg所绑定的Handler(Message.target)执行dispatchMessage方法以实现对Message的处理。

Handler的dispatchMessage的源码如下:

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

我们可以看到handler提供了三种途径来处理message,而且处理有优先级之分。首先尝试让post方法中传入的runnable对象去执行,其次尝试让Handler构造函数中传入的Callback的handleMessage方法处理,最后才是让Handler自身的handleMessage方法处理Message。

  • Callback是Handler的内部接口,它的内部有一个我们非常熟悉的handleMessage()方法。
public interface Callback {
        public boolean handleMessage(Message msg);
    }

Handler.Callback是用来处理Message的一种手段,如果没有传递该参数,那么就应该重写Handler的handleMessage方法,也就是说为了使得Handler能够处理Message,我们有两种办法:

  • 向Hanlder的构造函数传入一个Handler.Callback对象,并实现Handler.Callback的handleMessage方法。
  • 无需向Hanlder的构造函数传入Handler.Callback对象,但是需要重写Handler本身的handleMessage方法 。
    也就是说无论哪种方式,我们都得通过某种方式实现handleMessage方法。

好了,Handler的源码分析到这里的话就已经结束了,记住三个东西,Handler、Looper、MessageQueue,以及Looper对象怎么获取,通过prepare(),从ThreadLocal中取出looper对象,并获取一个MessageQueue对象,然后就是消息怎么放到消息队列中,通过Handler的很多发送消息方法,但是最终都是走到 queue.enqueueMessage()方法把消息加入消息队列中去,最后就是怎么取出消息,通过Looper.loop()方法,其中有个死循环,然后把消息发送给target,也就是我们的handler。关于消息的处理,就是分三个优先级,先让msg的callback来处理,不行就让handler的callback来处理,再不行,就让handler自己的handleMessage()方法来处理。

这样应该很清楚了吧~~~~好累啊Ծ‸Ծ

四、在子线程中使用Handler

我们知道,直接在子线程中使用handler会出错,为什么呢?因为Handler本质是从当前的线程中获取到Looper来监听和操作MessageQueue,当其他线程执行完成后回调当前线程。主线程中已经在入口方法main()中帮我们预先设置了一个looper,而子线程中并没有预先设置Looper,所以当调用looper.myLooper()方法时会因为找不到looper对象而报错。所以,我们如果想在子线程中使用,必须在声明Handler之前,调用Looper.prepare(),然后调用Looper的loop()方法来启动Looper让消息队列转动起来。

class DownLoadThread implements Runnable {  
        public Handler myHandler;  
        // 实现Runnable接口的线程体 
        @Override  
        public void run() {  

         /*①、调用Looper的prepare()方法为当前线程创建Looper对象并,
          创建Looper对象时,它的构造器会自动的创建相对应的MessageQueue*/
            Looper.prepare();  

            /*.②、创建Handler子类的实例,重写HandleMessage()方法,该方法处理除当前线程以外线程的消息*/
             myHandler = new Handler() {  
                @Override  
                public void handleMessage(Message msg) {  
                    String ms = "";  
                    if (msg.what == 0x777) {  

                    }  
                }  
            };  
            //③、调用Looper的loop()方法来启动Looper让消息队列转动起来
            Looper.loop();  
        }
    }

五、Handler引起的内存泄漏问题及解决办法

因为Handler是非静态匿名内部类,所以当他在Activity中使用的时候就是非静态匿名内部类持有外部类的引用,这样会导致Activity无法释放,造成内存泄漏。
解决办法:

  • 让handler变成静态内部类;
  • 持有activity的弱引用;
  • 在Activity的onDestroy()方法中调用mHandler.removeCallback();

AsyncTask

一、什么是AsyncTask?

AsyncTask就是一个封装了线程池和Handler的异步框架,适用于简单的异步处理。

二、AsyncTask的使用

我们一般是写一个类继承AsyncTask,然后重写里面的方法。
提到AsyncTask,那么我们就必须要有三个参数,五个方法的概念。

三个参数

public abstract class AsyncTask {}

Params: 输入参数,对应excute()方法中传递的参数。如果不需要传递参数,则直接设为void即可。

Progress:后台任务执行的百分比

Result:返回值类型,和doInBackground()方法的返回值类型保持一致。

五个方法

protected abstract Result doInBackground(Params... params);

protected void onPostExecute(Result result) {
    }

protected void onProgressUpdate(Progress... values) {
    }

protected void onPreExecute() {
    }

protected void onCancelled() {
    }

有两个方法必须要实现:执行异步操作,并更新UI

  • doInBackground:在子线程(其他方法都在主线程执行)中执行比较耗时的操作,不能更新UI,可以在该方法中调用publishProgress(Progress…)来更新任务的进度。Progress方法是AsycTask中一个final方法只能调用不能重写。
  • onPostExecute(Result):使用在doInBackground 得到的结果处理操作UI, 在主线程执行,任务执行的结果作为此方法的参数返回。

    其他三个方法根据需要来重写:

  • onProgressUpdate(Progress…):可以使用进度条增加用户体验度。 此方法在主线程执行,用于显示任务执行的进度。
  • onPreExecute():这里是最终用户调用Excute时的接口,当任务执行之前开始调用此方法,可以在这里显示进度对话框。
  • onCancelled():用户调用取消时,要做的操作。

注意:只有doInBackground方法是在子线程执行的,其他四个方法都是主线程中执行的。

在主线程中申明该类的对象,调用对象的execute()函数开始执行。

MyAsyncTask t = new MyAsyncTask();
t.execute();

三、AsyncTask的实现原理

一开始我们就说了AsyncTask是一个封装了线程池和Handler的异步框架,所以它的实现原理如下:

  • AsyncTask的本质是一个静态的线程池,AsyncTask派生出的子类可以实现不同的异步任务,这些任务都是提交到静态的线程池中执行。
  • 线程池中的工作线程执行doInBackground方法执行异步任务。
  • 当任务状态改变后,工作线程会向UI线程发送消息,AsyncTask内部的InternalHandler响应这些消息,并调用相关的回调函数。

四、使用AsyncTask的注意事项

  • AsyncTask只能执行一些轻量级的耗时操作,而且它只能在主线程中创建,因为耗时操作都是在子线程中创建的,所以可能会导致activity被销毁了,但是耗时操作还没有结束,所以,可能会导致activity无法被系统回收而导致内存泄漏。
  • 每一个AsyncTask只能被运行一次。

HandlerThread

一、什么是HandlerThread ?

要想知道这个问题,我们首先要知道HandlerThread的由来。
当我们需要执行耗时操作时,很自然的会想到开启一个子线程,当耗时操作完成之后,线程自动销毁。之后如果我们又需要执行另一个耗时操作,再开启一个子线程,这时就涉及到一个性能问题了。要知道,频繁的创建和销毁线程是很耗费系统资源的,所以,为了解决这个问题,Android给我们提供了HandlerThread这个类。
它有如下几个特点:

  • HandlerThread本质上是一个线程类,它继承了Thread;
  • HandlerThread有自己的内部Looper对象,可以进行looper循环;
  • 通过获取HandlerThread的Looper对象传递给Handler对象,可以在handleMessage方法中执行异步任务。
  • 优点是不会阻塞,减少了对性能的消耗,缺点是不能同时进行多任务的处理,需要等待进行处理,处理效率低。
  • 与线程池的并发不同,HandlerThread是一个串行队列,HandleThread背后只有一个线程,也就是说它的异步任务是一个接一个的执行的。

总结一下:HandlerThread内部封装了一个looper对象,通过获取它的looper对象将异步任务传递给Handler的handleMessage()方法执行。

二、HandlerThread的使用

它的使用非常简单:

HandlerThread ht = new HandlerThread("newThread");
        ht.start();
        mHandler = new Handler(ht.getLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //do something
            }
        };

声明一个HandlerThread对象并传入一个字符串参数,然后调用start()方法启动HandlerThread,将HandlerThread里的Looper传入Handler。最后记得在Activity的onDestroy()方法中将HandlerThread关闭。

@Override
    protected void onDestroy() {
        super.onDestroy();
        //释放资源
        ht.quit() ;
    }

使用起来是不是非常简单,跟我们平时使用Handler是不是没有大的区别,那为什么要使用呢?接下来我们分析一下它的源码。

三、 HandlerThread源码分析

public class HandlerThread extends Thread {}

首先它是继承自Thread的,所以说它本质上也是一个Thread类,所以当我们new HandlerThread()时,实际上就是开启了一个子线程,然后调用它的start方法。

接下来我们看一下关键的run方法:

@Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

run()方法里面调用了Looper.prepare()和Looper.loop(),这个过程是不是很眼熟,我们前面说过了在子线程中使用Handler,需要自己调用这两个方法,而我们在声明Handler时,将这个Looper对象通过getLooper()方法获取到并作为参数传入了进去

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

如果你够细心你会发现,run方法里面当mLooper创建完成后有个notifyAll(),getLooper()中有个wait(),这是为什么呢?因为mLooper在一个线程中执行,而我们的handler是在UI线程初始化的,也就是说,我们必须等到mLooper创建完成,才能正确的返回getLooper();wait(),notify()就是为了解决这两个线程的同步问题。

结合前面对Handler的分析,我们知道,当我们需要在子线程与子线程之间进行通信,也就是需要在子线程中使用Handler时,需要手动去操作Looper,这是很不推荐的做法。所以Google官方很贴心的帮我们封装好了一个类,那就是刚才HandlerThread啦。

最后再来看看quit()方法:

public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }

public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }

两个方法最后都是调用MessageQueue里面的quit(boolean)方法:

void quit(boolean safe) {
        if (!mQuitAllowed) {
            throw new IllegalStateException("Main thread not allowed to quit.");
        }

        synchronized (this) {
            if (mQuitting) {
                return;
            }
            mQuitting = true;

            if (safe) {
                removeAllFutureMessagesLocked();
            } else {
                removeAllMessagesLocked();
            }
            nativeWake(mPtr);
        }
    }

当我们调用Looper的quit方法时,实际上执行了MessageQueue中的removeAllMessagesLocked方法,该方法的作用是把MessageQueue消息池中所有的消息全部清空,无论是延迟消息(延迟消息是指通过sendMessageDelayed或通过postDelayed等方法发送的需要延迟执行的消息)还是非延迟消息。

当我们调用Looper的quitSafely方法时,实际上执行了MessageQueue中的removeAllFutureMessagesLocked方法,通过名字就可以看出,该方法只会清空MessageQueue消息池中所有的延迟消息,并将消息池中所有的非延迟消息派发出去让Handler去处理,quitSafely相比于quit方法安全之处在于清空消息之前会派发所有的非延迟消息。

无论是调用了quit方法还是quitSafely方法只会,Looper就不再接收新的消息。即在调用了Looper的quit或quitSafely方法之后,消息循环就终结了,这时候再通过Handler调用sendMessage或post等方法发送消息时均返回false,表示消息没有成功放入消息队列MessageQueue中,因为消息队列已经退出了。

IntentService

一、 IntentService是什么?

IntentService是继承并处理异步请求的一个类,在IntentService内有一个工作线程来处理耗时操作,启动IntentService的方式和传统的Service一样,同时,当任务执行完后,IntentService会自动停止,而不需要我们手动去控制或者stopSelf()。另外,可以启动IntentService多次,而每一次耗时操作会以工作队列的方式在IntentService的onHandleIntent回调方法中执行,并且,每次只会执行一个工作线程,执行完第一个再执行第二个。

  • 它本质是一种特殊的Service,继承自Service并且本身就是一个抽象类。
  • 它内部通过HandlerThread和Handler实现异步操作。

二、IntentService的基本使用

继承IntentService实现自己类,并重写构造函数和onHandleIntent()方法,onHandleIntent()是个异步方法,可以执行耗时操作。

public class MyIntentService extends IntentService {

    public static final String INDEX_FLAG = "index_flag";
    public static UpdateUI updateUI;

    public MyIntentService(String name) {
        super(name);
    }

    public static void setUpdateUI(UpdateUI updateUIInterface) {
        updateUI = updateUIInterface;
    }

      //运行在子线程的方法,intent是从启动该服务的context传过来的
    @Override
    protected void onHandleIntent(Intent intent) {
        try {
            Thread.sleep(5000);
            Message msg = new Message();
            msg.what = intent.getIntExtra(INDEX_FLAG, 0);
            msg.obj = "返回的值" + msg.what;
            if (updateUI != null)
                updateUI.updateUI(msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    public interface UpdateUI {
        void updateUI(Message message);
    }
}

Activity中启动该服务并设置回调

public class MainActivity extends AppCompatActivity implements MyIntentService.UpdateUI {

    private static TextView mTextView;

    private static final Handler mUIHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            mTextView.setText((String) msg.obj);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mTextView = findViewById(R.id.text);

        Intent intent = new Intent(this, MyIntentService.class);
        for (int i = 0; i < 7; i++) {
            intent.putExtra(MyIntentService.INDEX_FLAG, i);
            startService(intent);
        }
        MyIntentService.setUpdateUI(this);

    }

    @Override
    public void updateUI(Message message) {
        mUIHandler.sendMessageDelayed(message, message.what * 1000);
    }
}

activity中循环启动了7次service,但实际只有一个IntentService实例,IntentService会依次执行这7次操作,然后通过UpdateUI 接口回调结果更新UI。

三、IntentService源码分析

public abstract class IntentService extends Service {}

首先我们可以看到IntentService 是继承自service的,所以IntentService本质还是个Service,那我们就去看它的onCreate()方法:

@Override
    public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

在onCreate()方法中,创建了一个HandlerThread实例对象并将它传入了ServiceHandler对象中,ServiceHandler实际就是一个Handler,所以通过这一步,IntentService具备了进行异步操作的能力。接着我们来看onStart()方法

@Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

在onStart()中,通过ServiceHandler发送了一条附带startId和Intent的Message,最终这个Message会被发送到持有looper的ServiceHandler的handleMessage()方法中

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

handleMessage中执行了onHandleIntent()这个方法,也就是我们继承IntentService时需要重写的抽象方法,所以onHandleIntent()是个异步方法,因为它是执行在HandlerThread开启的子线程中的。
值得注意的一点是当调用完onHandleIntent()之后ServiceHandler 调用了stopSelf(msg.arg1),这个方法跟stopSelf()的区别是stopSelf(msg.arg1)会判断当前的服务是不是最后的服务,如果不是则不关闭,等最后的服务完成后才关闭,而stopSelf()会直接关闭服务。

所以,IntentService的本质就是一个封装了HandlerThread和Handler的异步框架。

总结

好啦,关于安卓的异步消息处理机制就是这么多了,最基本的就是Handler,然后是封装了线程池和handler的AsyncTask,然后是内部封装了looper对象的HandlerThread,然后是封装了HandlerThread和handler的IntentService。

关于源码,一定要自己走一遍流程,点到每一个方法里面去,AndroidStudio可以通过Crtl+O来显示所有的方法,然后进行搜索。

如果还有不懂的,那就在留言区留言告诉我吧。

异步消息处理机制_第2张图片

你可能感兴趣的:(android基础)