美文网首页面试宝典Android高级开发面试题安卓开发相关
Android面试攻略(2)——异步消息处理机制

Android面试攻略(2)——异步消息处理机制

作者: 黎清海 | 来源:发表于2017-08-02 19:35 被阅读184次

    系列文章
    Android面试攻略(1)——Android基础
    Android面试攻略(2)——异步消息处理机制
    Android面试攻略(3)——View相关


    本篇文章主要涉及Handler、AsyncTask、HandlerThread、IntentService

    Handler

    一、什么是Handler

    当程序第一次启动的时候,Android会同时启动一条主线程( Main Thread)来负责处理与UI相关的事件,我们叫做UI线程。
    Android的UI操作并不是线程安全的(出于性能优化考虑),意味着如果多个线程并发操作UI线程,可能导致线程安全问题。

    为了解决Android应用多线程问题—Android平台只允许UI线程修改Activity里的UI组建,就会导致新启动的线程无法改变界面组建的属性值。

    简单的说:当主线程队列处理一个消息超过5秒,android 就会抛出一个 ANP(无响应)的异常,所以,我们需要把一些要处理比较长的消息,放在一个单独线程里面处理,把处理以后的结果,返回给主线程运行,就需要用的Handler来进行线程建的通信。

    handler通过发送和处理Message和Runnable对象来关联相对应的线程的MessageQueue。可以让对应的Message和Runnable在未来的某个时间点进行相应的处理(延时处理:postAtTime()、postDelayed())。让自己想要处理的耗时操作放在子线程,让更新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执行操作
    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原理分析

    首先我们来想看下Handler的构造方法

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

    前两个构造方法是没有传递Looper对象的,这两个方法内部会调用另一个构造方法

    public Handler(Callback callback, boolean async) {
            if (FIND_POTENTIAL_LEAKS) {
                final Class<? extends Handler> 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实例对象,再通过mLopper.mQueue获取了MessageQueue。也就是每个Handler 对应一个Looper对象,产生一个MessageQueue。那其实我们并没有做过Looper的保存操作,为什么这里可以拿到保存的Looper呢?其实,我们这里获取到的Looper,是主线程创建的时候,实现了Looper的两个重要的方法。我们来看下ActivtyThread.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(false)

    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都有了,下面该发送消息了,我们看看Handle发送消息的几个方法源码

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

    在该方法中有两件事需要注意:

    1. msg.target = this:该代码将Message的target绑定为当前的Handler
    2. queue.enqueueMessage :变量queue表示的是Handler所绑定的消息队列MessageQueue,通过调用queue.enqueueMessage(msg, uptimeMillis)我们将Message放入到消息队列中。
    通过下图可以看到完整的方法调用顺序: 图片来自网络

    消息放入消息队列之后,怎么处理呢?我们最后来看下loop()方法

    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对象不能为空,就是说loop()方法调用必须在prepare()方法的后面。
    Looper一直在不断的从消息队列中通过MessageQueue的next方法获取Message,然后通过代码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,而且处理有前后优先级之分:首先尝试让postXXX中传递的Runnable执行,其次尝试让Handler构造函数中传入的Callback的handleMessage方法处理,最后才是让Handler自身的handleMessage方法处理Message。

    Callback参数:Callback是Handler中的内部接口,需要实现其内部的handleMessage方法,Callback代码如下:

    public interface Callback {
            public boolean handleMessage(Message msg);
        }
    

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

    1. 向Hanlder的构造函数传入一个Handler.Callback对象,并实现Handler.Callback的handleMessage方法。
    2. 无需向Hanlder的构造函数传入Handler.Callback对象,但是需要重写Handler本身的handleMessage方法 。
      也就是说无论哪种方式,我们都得通过某种方式实现handleMessage方法,这点与Java中对Thread的设计有异曲同工之处。

    四、在子线程中使用Handler

    我们知道,在子线程中使用Handler会出错,为什么?
    Handler本质是从当前的线程中获取到Looper来监听和操作MessageQueue,当其他线程执行完成后回调当前线程。而子线程中并没有预先设置Looper,所以导致Handler调用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引起的内存泄漏以及解决办法

    原因:静态内部类持有外部类的匿名引用,导致外部Activity无法释放。
    解决办法:1. Handler内部持有外部Activity的弱引用。2. 把Handler改为静态内部类。3. 在Activity的onDestroy()方法中调用mHandler.removeCallback()。


    AsyncTask

    一、什么是AsyncTask

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


    二、基本使用

    继承AsyncTask类实现自己的类,并重写其中的方法。

    三个参数

    public abstract class AsyncTask<Params, Progress, Result> {}
    

    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() {
        }
    

    最少要重写以下这两个方法:

    • doInBackground(Params…)
        在子线程(其他方法都在主线程执行)中执行比较耗时的操作,不能更新UI,可以在该方法中调用publishProgress(Progress…)来更新任务的进度。Progress方法是AsycTask中一个final方法只能调用不能重写。

    • onPostExecute(Result)
        使用在doInBackground 得到的结果处理操作UI, 在主线程执行,任务执行的结果作为此方法的参数返回。    有时根据需求还要实现以下三个方法:

    • onProgressUpdate(Progress…)
        可以使用进度条增加用户体验度。 此方法在主线程执行,用于显示任务执行的进度。

    • onPreExecute()
        这里是最终用户调用Excute时的接口,当任务执行之前开始调用此方法,可以在这里显示进度对话框。

    • onCancelled()
        用户调用取消时,要做的操作

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

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

    三、AsyncTask的机制原理

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

    四、AsyncTask的注意事项

    1. AsyncTask不适合特别耗时的任务
      AsyncTask的生命周期和Activity的生命周期不同步,Activity销毁了但是AsyncTask中的任务还是会继续执行完毕,一个最典型的例子就是Activity的横竖屏切换,AsyncTask中引用的Activity不是当前的Activity,onPostExecute()中执行的仍然是上一个Activity。还有一个原因是因为AsyncTask在执行长时间的耗时任务时也会持有一个Activity对象,即使这个Activity已经不可见了,Android也无法对这个Activity进行回收,导致内存泄露

    2. AsyncTask只能在主线程中创建以及使用
      AsyncTask被用于执行异步任务,然后更新UI,所以最后的onPostExecute()方法执行在创建该AsyncTask对象的线程中,如果不在主线程中创建以及使用,就达不到更新UI的目的。

    3. 一个AsyncTask对象只能执行一次
      一个AsyncTask对象只能执行一次,即只能调用一次execute方法,否则会报运行时异常AsyncTask。这是源码注释中写的,但是我查阅资料也没有找到什么具体原因。本人学艺也不精...也就知道了不能重复对一个AsyncTask对象调用execute()方法。

    4. AsyncTask在不同的Android版本下的并行和串行问题
      关于AsyncTask的并行和串行问题,在不同的API下是有不同的。在Android1.6之前,AsyncTask是串行执行任务的;到了Android1.6时,开始采用线程池来并行执行任务;在Android3.0之后的版本中,AsyncTask又开始用一个线程串行执行任务。虽然Android3.0之后采用串行方式执行任务,但我们可以通过AsyncTask的executeOnExecutor(exe,params),自定义一个线程池来并行执行任务。


    HandlerThread

    一、什么是HandlerThread

    当我们需要执行耗时操作时,很自然的会想到开启一个子线程,当耗时操作完成之后,线程自动销毁。之后如果我们又需要执行另一个耗时操作,再开启一个子线程,这时就涉及到一个性能问题了。要知道,频繁的创建和销毁线程是很耗费系统资源的,所以,为了解决这个问题,Android给我们提供了HandlerThread这个类。
    好吧,其实初看这段话,我是没搞懂HandlerThread到底是干啥的,所以我们来看看它的用法先吧。


    二、HandlerThread的用法

    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的源码。


    三、HandlerThread的源码分析

    HandlerThread的源码不多,首先来看下类的继承关系

    public class HandlerThread extends Thread {}
    

    HandlerThread 继承自Thread,也就是说HandlerThread 本质就是一个线程类,所以当我们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中,因为消息队列已经退出了。


    四、HandlerThread的特点

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

    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,那我们就去看它的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的异步框架。


    参考资料
    Android 异步消息处理机制(Handler 、 Looper 、MessageQueue)源码解析
    Android异步任务机制之AsycTask

    相关文章

      网友评论

        本文标题:Android面试攻略(2)——异步消息处理机制

        本文链接:https://www.haomeiwen.com/subject/yinelxtx.html