Android异步消息处理机制之Handler、Looper、Message

为什么用异步消息处理机制?

因为Android UI线程是线程不安全的,在子线程中更新UI会直接程序崩溃,另外当UI线程需要执行一个比较耗时的操作的话(IO操作,网络通信等),若是执行时间超过5s,程序会直接ANR,为了解决上述问题,可以使用异步消息处理机制 HandlerHandler有两大用处:

  • 在未来的某个时间点执行调度Message或者Runnable对象
  • 将执行的操作以队列形式放到其他线程中,并可以实现线程间通信

Handler、Looper、Message

通常在主线程中创建Handler,在子线程中执行耗时操作,并在子线程中将执行结果通过handler传递到主线程中刷新UI,首先在Activity中创建handler

 Handler handler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    tv_text.setText("更新UI");
                    break;
                default:
                    break;
            }
        }
    };

新起一个子线程:

 new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //模拟耗时操作
                    Thread.sleep(2000);
                    //模拟子线程处理完数据,通过handler将结果传到主线程
                    handler.sendEmptyMessage(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

整个流程:首先在子线程中处理耗时操作,当子线程处理完后,通过handler将处理结果传到主线程用来刷新UI,通过handler就完成了线程间的通信,那么handler内部是怎么运行的呢?

Handler源码

 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()来创建了一个Looper对象,如果Looper为空,则抛出异常Can't create handler inside thread that has not called Looper.prepare(),来看Looper.myLooper()

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

sThreadLocal对象中取出Looper,如果sThreadLocal中有Looper存在就返回Looper,如果没有则返回null了,sThreadLocal对象什么时候set的呢?答案是Looper.prepare()

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
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.prepare()只能被调用一次,即一个handler只能对应一个Looper,如果被多次调用,则会抛出异常:Only one Looper may be created per thread,如果在子线程使用handler,必须首先调用Looper.prepare()来创建Looper;但是我们在主线程中并没有调用Looper.prepare(),也没有崩溃呀!这是因为系统已经为我们创建好了:

public final class ActivityThread {
    public static void main(String[] args) {
        ......//省略其他代码
        Looper.prepareMainLooper();
        ......//省略其他代码
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
}

来看Looper.prepareMainLooper()方法:

 public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

因此我们的主线程一直有Looper对象,再来看Looper.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;
        ......//省略其他代码
        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.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);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            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();
        }
    }

ActivityThreadmain()方法执行 Looper.loop()后,主线程就开始无限循环处理消息,没有消息时阻塞等待,既然无限循环为什么主线程没有因为死循环而卡死呢?原因可以参考下这篇文章:Android中为什么主线程不会因为Looper.loop()里的死循环卡死?
handler创建完成,就可以发送Message了,来看Message都有哪些成员变量:

//Message的识别码,用来区别不同的Message
public int what;
//arg1 arg2都是用来传递整形数据
public int arg1;
public int arg2;
//可以传递任意数据
public Object obj;

创建一个新消息,如:

Message message = Message.obtain();//建议使用Message.obtain()而不是new Message(),Message.obtain()可以从消息池中取消息
 message.what = 1; //识别码为1
 message.arg1 = 100; //携带int类型数 100和101
 message.arg2 = 101;
 message.obj = MyObject;//携带MyObject对象
 Bundle bundle = new Bundle(); //封装bundle
 bundle.putString("key", "value");
 message.setData(bundle);
 handler.sendMessage(message); //通过handler将Message送到消息队列中

来看handler都有哪些处理Message的常用方法:

方法备注
sendEmptyMessage( int what)只包含what的Message
sendEmptyMessageDelayed( int what, long delayMillis)只包含what的Message,延迟delayMillis之后发送
sendEmptyMessageAtTime( int what, long uptimeMillis)发送空消息最终会调用的方法,uptimeMillis=SystemClock.uptimeMillis() + delayMillis,其中SystemClock.uptimeMillis()表示从开机到现在的毫秒数
sendMessage(Message msg)发送消息
sendMessageDelayed(Message msg, long delayMillis)延迟发送消息,delayMillis为延迟时间
sendMessageAtTime(Message msg, long uptimeMillis)发送消息最终会调用的方法,uptimeMillis=SystemClock.uptimeMillis() + delayMillis,其中SystemClock.uptimeMillis()表示从开机到现在的毫秒数
dispatchMessage(Message msg)分发消息
handleMessage(Message msg)处理消息
removeMessages( int what)移除在MessageQueue里面识别码为what的消息
post(Runnable r)将Runnable转换成一条消息,见下面
postAtTime(Runnable r, long uptimeMillis)将Runnable转换成一条消息定时发送,见下面
postDelayed(Runnable r, long delayMillis)将Runnable转换成一条消息延时发送,见下面
removeCallbacks(Runnable r)移除runnable

上面表格中除了直接发送Message外,还可以用post一个runnable,看post()方法:

 public final boolean post(Runnable r)
    {
     //通过getPostMessage()方法将Runnable 转换成消息
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
 private static Message getPostMessage(Runnable r) {
        //新建一个Message
        Message m = Message.obtain();
        //Runnable 作为Message的一个变量callback 
        m.callback = r;
        return m;
    }
public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

可见post(runnable)最终也是调用sendMessageAtTime()来发送消息MessageQueue的。通过上面的代码我们知道runnable 作为Message的一个变量callback 封装到Message中了,那么什么时候回调这个runnable呢?答案是当我们new Handler()时执行Looper.loop()的时候,会执行一句msg.target.dispatchMessage(msg),其中msg.target即是发送Messagehandler,最终处理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);
    }
  }
private static void handleCallback(Message message) {
        message.callback.run();
    }

如果callback 不为null,则执行handleCallback(msg),直接回调runnable里的run()方法;如果callbacknull,则执行HandlerhandleMessage来处理之前传递到MessageQueue的消息,整个过程:

handler.jpg

总结:

1、在子线程中更新UI有多种: Handler发送Message、Handler的post(runnable)方法、View.post()方法、Activity的runOnUiThread()方法
2.Handler的初始化会获取到当前线程的Looper对象,并通过Looper获得对应的MessageQueue对象
3.如果在子线程中使用Handler,必须首先调用Looper.prepare(),如:

new Thread(new Runnable() {
            @Override
            public void run() {
                Looper.prepare();
                //初始化Handler之前必须先调用Looper.prepare()
                Handler handler = new Handler();
                Looper.loop();
            }
        }).start();

4.Handler在当前线程初始化时创建了对应的Looper,Looper初始化时又会创建对应的MessageQueue,一个线程中只有一个Looper和一个MessageQueue,但可以有多个Handler,他们往同一个MessageQueue中发送消息并且Looper从MessageQueue中取出消息后,再交给发送这个Message的Handler去处理。

PS:关于Handler使用可能会内存泄露问题,可以参考这篇文章:Android中Handler引起的内存泄露

参考:
1、Android 中线程间通信原理分析:Looper, MessageQueue, Handler
2、Android异步消息处理机制完全解析,带你从源码的角度彻底理解
3、Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_小马快跑_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值