Android之异步消息处理机制Handler源码解析

转载请标明出处:
http://blog.csdn.net/hai_qing_xu_kong/article/details/76083113
本文出自:【顾林海的博客】

个人开发的微信小程序,目前功能是书籍推荐,后续会完善一些新功能,希望大家多多支持!在这里插入图片描述

前言


我们知道在应用启动时会开启一个主线程,也就是UI线程,主线程主要管理与用户交互的UI控件(UI展示,事件分发),如果在主线程中执行耗时操作会触发ANR(Application not responding)异常,意思是程序未响应,这时就需要开启子线程来执行耗时操作,这时又会引发到子线程更新UI的问题,这里要记住Android中主线程是不安全的,为了解决子线程能更新UI状态,因此在Android平台中引入了一个叫做Handler机制,可以通过在子线程通过Handler发送消息给主线程来进行UI的更新,并且在子线程中可以进行耗时操作。总的来说Handler通过发送和处理Message和Runnable对象来关联相对应线程的MessageQueue。

Handler的使用方法


  1. 通过post(runnable)方法进行延迟消息的处理。
  2. 通过sendMessage(message)方法进行子线程与主线程之间的消息传递。


    首先我们演示第一种方式,通过post(runnable)方法来进行消息的处理,具体代码如下:

package com.glh.intentservice;

import android.os.Bundle;
import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    private TextView mInfoTextView;
    private Button mDownloadButton;

    private static Handler mHandler = new Handler();


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        initEvent();
    }

    private void initView() {
        mInfoTextView = (TextView) findViewById(R.id.tv_info);
        mDownloadButton = (Button) findViewById(R.id.btn_download);
    }

    private void initEvent() {
        mDownloadButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                mInfoTextView.setText("下载中...");
                new DownloadThread(0).start();
            }
        });
    }

    class DownloadThread extends Thread {

        private int mProcess = 0;

        DownloadThread(int process) {
            mProcess = process;
        }

        @Override
        public void run() {
            while (mProcess < 100) {
                mProcess++;
            }
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    mInfoTextView.setText("下载成功");
                }
            };
            mHandler.post(runnable);
        }
    }

}

分析上面代码,我们在创建Handler时,是在主线程中创建的,也就是说这个Handler绑定在主线程中,代码中,创建继承自Thread类的DownloadThread的线程类,并在run方法中执行了一个耗时操作,这里可以看出执行完耗时操作后,创建了一个Runnable对象,并在Runnable中的run方法中进行UI的更新,最后通过Handler的post方法进行消息的处理。

最后看看sendMessage(message)方法使用,代码如下:
package com.glh.intentservice;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.lang.ref.WeakReference;

public class MainActivity extends AppCompatActivity {

    private TextView mInfoTextView;
    private Button mDownloadButton;

    private MyHandler mHandler = new MyHandler(this);

    static class MyHandler extends Handler {

        private WeakReference<MainActivity> weakReference;

        MyHandler(MainActivity activity) {
            weakReference = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            MainActivity activity = weakReference.get();
            if (null != activity) {
                int what = msg.what;
                switch (what) {
                    case 1:
                        activity.downloadSuccess((String) msg.obj);
                        break;
                    default:
                        break;
                }

            }
        }
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
        initEvent();
    }

    private void initView() {
        mInfoTextView = (TextView) findViewById(R.id.tv_info);
        mDownloadButton = (Button) findViewById(R.id.btn_download);
    }

    private void initEvent() {
        mDownloadButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                mInfoTextView.setText("下载中...");
                new DownloadThread(0).start();
            }
        });
    }

    private void downloadSuccess(String info) {
        mInfoTextView.setText(info);
    }

    class DownloadThread extends Thread {

        private int mProcess = 0;

        DownloadThread(int process) {
            mProcess = process;
        }

        @Override
        public void run() {
            while (mProcess < 100) {
                mProcess++;
            }
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Message message = Message.obtain();
            message.what = 1;
            message.obj = "下载成功";
            mHandler.sendMessage(message);
        }
    }

}

> 在代码中创建一个静态内部类MyHandler,为什么要创建静态内部类呢?这是因为,非静态内部类会持有外部类Activity的匿名引用,如果在子线程执行耗时操作,在耗时操作时,Activity退出,通过Handler发送消息,这时由于Activity不存在会引起Activity的内存泄露,因此这里使用静态内部类,并使用WeakReference弱引用。 > 代码中创建了一个线程,并执行了耗时操作,耗时操作完毕后,创建了Message对象,并给Message的what设置1,obj设置"下载成功",这里的what属性用于在主线程中Handler的handleMessage方法中进行不同Message的处理,obj属性用于携带相关数据。最后通过Handler的sendMessage(message)方法发送消息给主线程,主线程的Handler的handleMessage方法中通过msg.what识别哪个message,并进行相应的处理。

Handler机制

在讲解Handler机制时,先来了解一下Looper、MessageQueue、Message所代表的含义。Handler主要包含两种作用,分别是发送消息到消息队列和处理消息;Looper用于为当前线程生成一个消息队列,并执行一个循环,不停的从消息队列中获取Message消息;MessageQueue就是一个先进先出的消息队列,提供了next方法用于获取Message消息,以及enqueueMessage方法将消息添加到消息队列中;Message代表消息。


在Android中新开启的线程是没有开启消息循环的(主线程除外),如果在子线程中开启消息循环就需要这样做:

class LooperThread extends Thread {
    public Handler mHandler;

    public void run() {
        Looper.prepare();
        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };

        Looper.loop();
    }
}

在run方法中主要三件事:

  • 通过Looper.prepare实例化Looper对象,并生成一个消息队列。
  • 创建Handler,并与Looper相关联。
  • 通过Looper.loop开启消息循环,并处理消息。


    先查看Looper,prepare()方法:
public static void prepare() {
    prepare(true);
}

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


在prepare方法中sThreadLocal是ThreadLocal对象,在创建Handler时通过sThreadLocal获取当前线程的Looper,这个在后面会提到,上面代码中会先判断sThreadLocal是否为null,如果不为null,就抛出异常,说明Looper.prepare()方法不能执行两次以上,也就是说一个线程中只有一个Looper实例,接着看Looper的构造器。
private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}

在Looper构造器中创建了MessageQueue对象,mThread是指当前的线程。到这里Looper.prepare()方法执行完毕,总结Looper.prepare方法做了如下工作:
  • 一个线程只能有一个Looper实例。
  • 创建Looper时,会关联一个MessageQueue。


    接着看Looper.loop()方法:
public static void loop() {
    final Looper me = myLooper();
    final MessageQueue queue = me.mQueue;

    for (; ; ) {
        //没有消息时阻塞
        Message msg = queue.next(); // might block
        if (msg == null) {
            return;
        }
        try {
            //通过Handler方法消息
            msg.target.dispatchMessage(msg);
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }
        //消息的回收
        msg.recycleUnchecked();
    }
}

上面的代码进行了局部精简,在loop()方法中,先是通过myLooper()方法获取当前线程的Looper对象,在myLooper()方法中通过sThreadLocal.get()方法获取Looper对象,这里的sThreadLocal在讲解Looper.prepare()方法时已经讲过了。接着获取当前Looper的MessageQueue消息队列,并通过一个无限循环遍历消息队列,当消息队列中没有消息时处于阻塞状态,当消息队列中有消息时,取出消息,通过msg.target的dispatchMessage方法发送消息,这里的msg.target就是Handler,最后进行消息的回收。总结Looper.loop()方法做了如下工作:
  • 获取当前线程Looper对象。
  • 从当前线程中的Looper对象中获取消息队列。
  • 开启无限循环,遍历消息队列。
  • 在循环中通过msg.target进行消息的发送。

最后看看Handler的源码:

public Handler() {
    this(null, false);
}


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


mLooper是之前在Loop.prepare()方法执行时关联的Looper对象,这这段代码中会去判断mLooper是否空,如果为空抛出异常,说明创建Handler之前需要通过Looper.prepare()方法创建当前线程的Looper对象并创建一个MessageQueue消息队列,这样的话Handler才能与MessageQueue进行关联,这里面mQueue就是Looper创建的MessageQueue对象。


Handler创建完毕后就需要我们进行发送消息,这里主要分析前面两种Handler使用方法:

  1. 通过post(runnable)方法进行延迟消息的处理。
  2. 通过sendMessage(message)方法进行子线程与主线程之间的消息传递。

public final boolean post(Runnable r)
{
   return  sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}


通过post(runnable)方法进行消息的处理时,Handler内部会调用sendMessageDelayed方法,而sendMessageDelayed方法的第一个参数就是Message对象,通过getPostMessage(runnable)方法进行包装,在getPostMessage方法中获取Message对象,并将Runnable对象赋值给Message的callback属性。
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}


一直往下追溯,最终调用的是enqueueMessage方法,在enqueueMessage方法中,将当前的Handler赋值给Message的target属性,这里面的msg.target是不是很熟悉,在之前Looper.loop()方法中进行消息队列的遍历,最终就是通过它来发送消息的。这里的queue就是与当前线程关联的Looper对象的MessageQueue,执行到最后通过MessageQueue的enqueueMessage方法将Message放入消息队列中。


接着查看sendMessage(message)方法的实现原理:

public final boolean sendMessage(Message msg)
{
    return sendMessageDelayed(msg, 0);
}
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}


查看到这里,大家就会察觉到,这里与上面通过post(runnable)方法的实现逻辑是一样,都是通过MessageQueue的enqueueMessage方法将Message放入消息队列中。当消息放入消息队列MessageQueue后,是如何获取Message并进行处理的呢?这里又回到了上面Looper.loop()方法中的无限循环遍历消息队列中的msg.target的dispatchMessage方法,从上面存放消息队列的分析中,我们已经知道了msg.target就是一个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);
    }
}


这里面的callback就是Message中的Runnable对象,我们在上面讲解Handler的使用方法中讲的第一种方法,通过post(runnable)方法,这里面的runnable在post(runnable)源码中封装Message时,已经赋值给了Message的callback属性,回到上面的代码中,第一步判断Message的callback属性是否为空,不为空执行handleCallback(msg)方法,如果为空,判断当前Handler的mCallback属性是否为空,如果不为空,执行Callback 的handleMessage的方法,如果Handler的mCallback属性为空或者是Callback的handleMessage方法返回false,执行Handler中的方法handleMessage(msg),这里面的mCallback是一个内部Callback接口:
public interface Callback {
    public boolean handleMessage(Message msg);
}

handleMessage方法是不是很熟悉,没错,它是在创建Handler时,如果实现了handleMessage方法,也就是说交由Handler来处理消息时,会执行这个方法。如果只是new Handler(),那么这个mCallback为空。

如果通过post(runnable)方法处理消息,这时会执行handleCallback(msg)方法:

private static void handleCallback(Message message) {
    message.callback.run();
}


很简单,就是调用Runnable的run()方法,准确来说,post(runnable)并没有开启线程,只是纯粹的调用Runnable的run方法,这也说明了为什么通过Handler可以更新UI。

到此Handler机制原理解析完毕。

©️2020 CSDN 皮肤主题: 猿与汪的秘密 设计师:上身试试 返回首页