从源码的角度解析Android异步消息处理机制

最新推荐文章于 2021-09-21 10:07:27 发布

zy_rainbow

最新推荐文章于 2021-09-21 10:07:27 发布

阅读量470

点赞数 1

分类专栏： Android积累 Android基础文章标签：异步 android handler机制

Android积累同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

Android基础

5 篇文章 0 订阅

订阅专栏

转载于：
http://blog.csdn.net/guolin_blog/article/details/9991569
http://www.cnblogs.com/JczmDeveloper/p/4403129.html

1.前言

Android UI是线程不安全的，如果在子线程中尝试进行UI操作，程序就有可能会崩溃。
在一个Activity中，当有多个线程更新UI时，并且没有枷锁机制，就会出现更新界面混乱，但是如果有枷锁机制的话，又会导致性能下降，此时使用Handler机制，通过消息队列，保证了消息处理的先后顺序，进而很好的更新了界面。
解决的方案应该也是早已烂熟于心，即创建一个Message对象，然后借助Handler发送出去，之后在Handler的handleMessage()方法中获得刚才发送的Message对象，然后在这里进行UI操作就不会再出现崩溃了，解决多线程并发的问题。

在下面介绍handler机制前，首先得了解以下几个概念：

Message
消息，理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI，则可发送一条包含更新信息的Message给UI线程。
Message Queue
消息队列，用来存放通过Handler发布的消息，按照先进先出(FIFO)执行。
Handler
Handler是Message的主要处理者，负责将Message添加到消息队列以及对消息队列中的Message进行处理。
Looper
循环器，扮演Message Queue和Handler之间桥梁的角色，循环取出Message Queue里面的Message，并交付给相应的Handler进行处理。
线程
UI thread 通常就是main thread，而Android启动程序时会替它建立一个Message Queue。
每一个线程里可含有一个Looper对象以及一个MessageQueue数据结构。在你的应用程序里，可以定义Handler的子类别来接收Looper所送出的消息。

2.代码分析

(1)Handler的作用

传递message
用于接受子线程发送的数据，并用此数据配合主线程更新UI。

sendEmptyMessage(int what);
sendMessage(Message msg);
sendMessageAtTime(Message msg,long uptimeMillis);//uptimeMillis 自系统开机到当前时间的毫秒数再加上延迟时间
sendMessageDelayed(Message msg,long delayMillis);
sendMessageAtFrontOfQueue(Message msg);

传递Runnable对象

post(Runnable run);
postAtTime(Runnable run,long uptimeMillis);
postDelayed(Runnable run,long delayMillis);

传递Callback对象
Callback用于截获handler发送的消息，如果返回true，就截获成功，不再往下传递。
如果返回false，则继续执行下面的handleMessage方法。

public Handler m = new Handler(new Handler.Callback(){
    public boolean handleMessage(Message msg) {
        Toast.makeText(context, "handle intercept", Toast.LENGTH_LONG).show();
        return true;
    };
}){
    public void handleMessage(Message msg) {
        Toast.makeText(context, "handleMessage", Toast.LENGTH_LONG).show();
    };
};

(2)Handler的原理

handler封装了message的发送
Looper内部包含一个Message Queue消息队列，所有handler发送的消息都走向这个队列。
Looper.loop()方法是一个for死循环，不断从Message Queue取消息，有消息就处理消息，没有消息就阻塞
Message Queue消息队列，可以添加消息，处理消息

Handler负责发送message，Looper负责接受Handler发送的message，并直接把message回传给handler自己，Message Queue就是一个存储消息的容器。
下图展示了具体流程：
这里写图片描述

一个线程中只有一个Looper实例，一个MessageQueue实例，可以有多个Handler实例。
如下图：
这里写图片描述

(3)子线程中创建Handler

1.自定义子线程并创建Handler

class MyThread extends Thread{
    private Handler m_Handler = null;
    @Override  
    public void run() {  
        Looper.prepare();  
        handler = new Handler(){
                    @Override
                    public void handleMessage(Message msg) {
                        if(1==msg.what){
                            super.handleMessage(msg);
                            try {
                                Thread.sleep(10000);
                                Toast.makeText(getApplicationContext(), "currentThread:"+Thread.currentThread().getName(), Toast.LENGTH_LONG).show();
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                    }
        };
        m_Handler.sendEmptyMessage(1);
        Looper.loop();
    }
}

//启动线程处理耗时操作
new MyThread().start();

一般UI主线程中不宜做耗时操作，此时就可以通过子线程中的消息机制来处理耗时操作。

主线程中创建Handler时，不需要调用Looper.prepare()和Looper.loop()，是因为系统已经帮我们自动调用们调用了。
子线程中创建的Handler时，需要先调用Looper.prepare(),否则会导致 crash：Can’t create handler inside thread that has not called Looper.prepare()，而且之后还需要调用Looper.loop()来循环从消息队列处理消息。之所以会这样，我们需要看下Handler源码：

public Handler() {  
    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 = null;  
}

源码中调用了Looper.myLooper()方法获取了一个Looper对象，如果Looper对象为空，则会抛出一个运行时异常，提示的错误正是 Can’t create handler inside thread that has not called Looper.prepare()！那什么时候Looper对象才可能为空呢？这就要看看Looper.myLooper()中的代码了，如下所示：

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

从sThreadLocal对象中取出Looper。如果sThreadLocal中有Looper存在就返回Looper，如果没有Looper存在自然就返回空了。因此你可以想象得到是在哪里给sThreadLocal设置Looper了吧，当然是Looper.prepare()方法！我们来看下它的源码：

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

首先判断sThreadLocal中是否已经存在Looper了，如果还没有则创建一个新的Looper设置进去。这样也就完全解释了为什么我们要先调用Looper.prepare()方法，才能创建Handler对象。同时也可以看出每个线程中最多只会有一个Looper对象。

接下来就是发送消息，除了sendMessageAtFrontOfQueue()方法之外，其它的发送消息方法最终都会辗转调用到sendMessageAtTime()方法中，这个方法的源码如下所示：

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

sendMessageAtTime()方法接收两个参数，其中msg参数就是我们发送的Message对象，而uptimeMillis参数则表示发送消息的时间，它的值等于自系统开机到当前时间的毫秒数再加上延迟时间，如果你调用的不是sendMessageDelayed()方法，延迟时间就为0，然后将这两个参数都传递到MessageQueue的enqueueMessage()方法中。这个MessageQueue又是什么东西呢？其实从名字上就可以看出了，它是一个消息队列，用于将所有收到的消息以队列的形式进行排列，并提供入队和出队的方法。这个类是在Looper的构造函数中创建的，因此一个Looper也就对应了一个MessageQueue。

enqueueMessage()方法毫无疑问就是入队的方法了，我们来看下这个方法的源码：

final boolean enqueueMessage(Message msg, long when) {  
    if (msg.when != 0) {  
        throw new AndroidRuntimeException(msg + " This message is already in use.");  
    }  
    if (msg.target == null && !mQuitAllowed) {  
        throw new RuntimeException("Main thread not allowed to quit");  
    }  
    synchronized (this) {  
        if (mQuiting) {  
            RuntimeException e = new RuntimeException(msg.target + " sending message to a Handler on a dead thread");  
            Log.w("MessageQueue", e.getMessage(), e);  
            return false;  
        } else if (msg.target == null) {  
            mQuiting = true;  
        }  
        msg.when = when;  
        Message p = mMessages;  
        if (p == null || when == 0 || when < p.when) {  
            msg.next = p;  
            mMessages = msg;  
            this.notify();  
        } else {  
            Message prev = null;  
            while (p != null && p.when <= when) {  
                prev = p;  
                p = p.next;  
            }  
            msg.next = prev.next;  
            prev.next = msg;  
            this.notify();  
        }  
    }  
    return true;  
}

MessageQueue并没有使用一个集合把所有的消息都保存起来，它只使用了一个mMessages对象表示当前待处理的消息。然后观察上面的代码的16~31行我们就可以看出，所谓的入队其实就是将所有的消息按时间来进行排序，这个时间当然就是我们刚才介绍的uptimeMillis参数。具体的操作方法就根据时间的顺序调用msg.next，从而为每一个消息指定它的下一个消息是什么。当然如果你是通过sendMessageAtFrontOfQueue()方法来发送消息的，它也会调用enqueueMessage()来让消息入队，只不过时间为0，这时会把mMessages赋值为新入队的这条消息，然后将这条消息的next指定为刚才的mMessages，这样也就完成了添加消息到队列头部的操作。

现在入队操作我们就已经看明白了，那出队操作是在哪里进行的呢?这个就需要看一看Looper.loop()方法的源码了，如下所示：

public static final void loop() {  
    Looper me = myLooper();  
    MessageQueue queue = me.mQueue;  
    while (true) {  
        Message msg = queue.next(); // might block  
        if (msg != null) {  
            if (msg.target == null) {  
                return;  
            }  
            if (me.mLogging!= null) me.mLogging.println(  
                    ">>>>> Dispatching to " + msg.target + " "  
                    + msg.callback + ": " + msg.what  
                    );  
            msg.target.dispatchMessage(msg);  
            if (me.mLogging!= null) me.mLogging.println(  
                    "<<<<< Finished to    " + msg.target + " "  
                    + msg.callback);  
            msg.recycle();  
        }  
    }  
}

可以看到，这个方法从第4行开始，进入了一个死循环，然后不断地调用的MessageQueue的next()方法，我想你已经猜到了，这个next()方法就是消息队列的出队方法。不过由于这个方法的代码稍微有点长，我就不贴出来了，它的简单逻辑就是如果当前MessageQueue中存在mMessages(即待处理消息)，就将这个消息出队，然后让下一条消息成为mMessages，否则就进入一个阻塞状态，一直等到有新的消息入队。继续看loop()方法的第14行，每当有一个消息出队，就将它传递到msg.target的dispatchMessage()方法中，那这里msg.target又是什么呢？其实就是Handler啦，你观察一下上面sendMessageAtTime()方法的第6行就可以看出来了。接下来当然就要看一看Handler中dispatchMessage()方法的源码了，如下所示：

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

在第5行进行判断，如果mCallback不为空，则调用mCallback的handleMessage()方法，否则直接调用Handler的handleMessage()方法，并将消息对象作为参数传递过去。这样我相信大家就都明白了为什么handleMessage()方法中可以获取到之前发送的消息了吧！

2.使用HandlerThread子线程

HandlerThread继承自Thread，它与普通Thread的区别在于内部有个Looper成员变量，这个Looper对象就是对消息队列以及消息队列逻辑处理的封装。当我们需要一个工作线程，且不是用过就废弃的话，就可以使用它。

private Handler mHandler；
private HandlerThread mHandlerThread；
private void setRunnableToWorker（Runnable r）{
    if(null == mHandlerThread){
        mHandlerThread = new HandlerThread("WorkThread");
        mHandlerThread.setPriority(Thread.MIN_PRIORITY);
        mHandlerThread.start();
    }

    if(null == mHandler){
        mHandler = new Handler(mHandlerThread.getLooper());
        mHandler.post(r);
    }
}

(4)主线程与子线程通过Handler信息交互

//方式一：
    private Handler mThreadHandler;//创建工作线程handler
    private HandlerThread mHandlerThread;//工作线程
    private void setRunnableToWorker(Runnable r){
        if(null == mHandlerThread){
            mHandlerThread = new HandlerThread("WorkThread");
            mHandlerThread.setPriority(Thread.MIN_PRIORITY);
            mHandlerThread.start();
        }
        if(null == mThreadHandler){
            mThreadHandler = new Handler(mHandlerThread.getLooper());
            mThreadHandler.post(r);
        }
    }
    //创建主线程handler
    private Handler m_Handler = new Handler(){
            public void handleMessage(Message msg) {
                if(msg.what == 1){
                    Toast.makeText(getApplicationContext(), "update UI", Toast.LENGTH_LONG).show();
                    tv.setText("hi");

                }
            };
    };
    //onResume()中调用setRunnableToWorker()处理耗时操作，并通过handler更新UI
    setRunnableToWorker(new Runnable() {

                @Override
                public void run() {
                    try {
                        Thread.sleep(10000);
                        m_Handler.sendEmptyMessage(1);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    Toast.makeText(getApplicationContext(), "update UI", Toast.LENGTH_LONG).show();

                }
    });


//方式二：
    private WorkHandler mWorkHandler;//创建工作线程的Handler
    private class WorkHandler extends Handler{
        public WorkHandler(Looper l){
            super(l);
        }
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            if(msg.what == 2){
                try {
                    Thread.sleep(10000);
                    m_Handler.sendEmptyMessage(1);//耗时操作处理完毕，发送消息给主线程更新UI                   
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    //创建主线程handler
    private Handler m_Handler = new Handler(){
            public void handleMessage(Message msg) {
                if(msg.what == 1){
                    Toast.makeText(getApplicationContext(), "update UI", Toast.LENGTH_LONG).show();
                    tv.setText("hi");

                }
            };
    };
    //创建工作线程
    private HandlerThread mWorkThread;
    //onResume()中
    mWorkThread = new HandlerThread("workThread");
    mWorkThread.start();
    mWorkHandler = new WorkHandler(mWorkThread.getLooper());
    mWorkHandler.sendEmptyMessage(2);//发送消息给工作线程，让其处理耗时操作

(5)Android中更新UI的方式

1.Handler的post()方法

public final boolean post(Runnable r)  
{  
   return  sendMessageDelayed(getPostMessage(r), 0);  
} 
//调用了sendMessageDelayed()方法去发送一条消息，并且还使用了getPostMessage()方法将Runnable对象转换成了一条消息

private final Message getPostMessage(Runnable r) {  
    Message m = Message.obtain();//可以避免重复创建Message对象  
    m.callback = r;  
    return m;  
}  
//在这个方法中将消息的callback字段的值指定为传入的Runnable对象。咦？这个callback字段看起来有些眼熟啊，喔！在Handler的dispatchMessage()方法中原来有做一个检查，如果Message的callback等于null才会去调用handleMessage()方法，否则就调用handleCallback()方法。

private final void handleCallback(Message message) {  
    message.callback.run();  
}  
//直接调用了一开始传入的Runnable对象的run()方法。因此在子线程中通过Handler的post()方法进行UI操作就可以这么写：

public class MainActivity extends Activity {  

    private Handler handler;  

    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        handler = new Handler();  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                handler.post(new Runnable() {  
                    @Override  
                    public void run() {  
                        // 在这里进行UI操作  
                    }  
                });  
            }  
        }).start();  
    }  
}

2.Activity的runOnUiThread()方法

public final void runOnUiThread(Runnable action) {  
    if (Thread.currentThread() != mUiThread) {  
        mHandler.post(action);  
    } else {  
        action.run();  
    }  
}  
//如果当前的线程不等于UI线程(主线程)，就去调用Handler的post()方法，否则就直接调用Runnable对象的run()方法。

3.View的post()方法

public boolean post(Runnable action) {  
    Handler handler;  
    if (mAttachInfo != null) {  
        handler = mAttachInfo.mHandler;  
    } else {  
        ViewRoot.getRunQueue().post(action);  
        return true;  
    }  
    return handler.post(action);  
} 
//最终调用的还是handler的post方法

4.Handler的sendMessage方法

见上述分析

zy_rainbow

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
从源码的角度解析Android异步消息处理机制

转载于：http://blog.csdn.net/guolin_blog/article/details/99915691.前言Android UI是线程不安全的，如果在子线程中尝试进行UI操作，程序就有可能会崩溃。在一个Activity中，当有多个线程更新UI时，并且没有枷锁机制，就会出现更新界面混乱，但是如果有枷锁机制的话，又会导致性能下降，此时使用Handler机制，通过消息队列，保证了
复制链接

扫一扫