Android Framework分析 ---- 1消息处理机制 java层

最新推荐文章于 2019-02-21 13:17:15 发布

xcy2011sky

最新推荐文章于 2019-02-21 13:17:15 发布

阅读量2.3k

点赞数 1

分类专栏： Android 文章标签： android thread 工作 windows class

本文链接：https://blog.csdn.net/xcy2011sky/article/details/7546086

版权

Android 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

在Android的系统中，无论是App层还是native层都有处理任务需要放在单独的线程处理。各个线程直接的协调处理需要消息传递和处理。本文主要介绍一下Android的消息传递和处理的机制。

首先简单说一下 Android 消息传递和处理模型。

android的消息传递主要是存在一个消息队列(先进先出的模型），该消息队列基于链表的数据结构。但是链表缺少休眠和唤醒机制。因此android 添加了一个管道，可以唤醒在read 端唤醒消息队列的进程。Android的消息机制可以分为2层。 java层和native层的消息传递和处理。

2.Java层消息处理机制。

涉及到关键类：Handler,Looper,Message,MessageQueue.

Handler 专门处理thread模板：HandlerThread。

Message：消息的定义类。

public final class Message implements Parcelable {
    /**
     * User-defined message code so that the recipient can identify 
     * what this message is about. Each {@link Handler} has its own name-space
     * for message codes, so you do not need to worry about yours conflicting
     * with other handlers.
     */
    public int what;

    /**
     * arg1 and arg2 are lower-cost alternatives to using
     * {@link #setData(Bundle) setData()} if you only need to store a
     * few integer values.
     */
    public int arg1; 

    /**
     * arg1 and arg2 are lower-cost alternatives to using
     * {@link #setData(Bundle) setData()} if you only need to store a
     * few integer values.
     */
    public int arg2;

    /**
     * An arbitrary object to send to the recipient.  When using
     * {@link Messenger} to send the message across processes this can only
     * be non-null if it contains a Parcelable of a framework class (not one
     * implemented by the application).   For other data transfer use
     * {@link #setData}.
     * 
     * <p>Note that Parcelable objects here are not supported prior to
     * the {@link android.os.Build.VERSION_CODES#FROYO} release.
     */
    public Object obj;

    /**
     * Optional Messenger where replies to this message can be sent.  The
     * semantics of exactly how this is used are up to the sender and
     * receiver.
     */
    public Messenger replyTo;

    /** If set message is in use */
    /*package*/ static final int FLAG_IN_USE = 1 << 0;

    /** If set message is asynchronous */
    /*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1;

    /** Flags to clear in the copyFrom method */
    /*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;

    /*package*/ int flags;

    /*package*/ long when;
    
    /*package*/ Bundle data;
    
    /*package*/ Handler target;     
    
    /*package*/ Runnable callback;   

    /*package*/ String fingerPrint;
    
    // sometimes we store linked lists of these things
    /*package*/ Message next;

Android系统中Looper负责管理线程的消息队列和消息循环，可以通过Loop.myLooper()得到当前线程的Looper对象，通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象。

前面提到Android系统的消息队列和消息循环都是针对具体线程的，一个线程只可以存在一个消息队列和一个消息循环（Looper），特定线程的消息只能分发给本线程，不能进行跨线程，跨进程通讯。但是创建的工作线程默认是没有消息循环和消息队列的，如果想让该线程具有消息队列和消息循环，需要在线程中首先调用Looper.prepare()来创建消息队列，然后调用Looper.loop()进入消息循环。如下例所示：

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

这样你的线程就具有了消息处理机制了，在Handler中进行消息处理。

Looper.loop() 会调用messagequeue 的next（）函数，

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
            Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }
            if (localLog != null) {
                me.mDispatching = msg.toStringLw();
                me.mDispatchStart = SystemClock.uptimeMillis();
            }


            msg.target.dispatchMessage(msg);

next()调用 nativePollOnce(mPtr, nextPollTimeoutMillis);获取消息，该函数是采用epoll的机制的，没有mes可以read时，进入休眠状态。但有消息是，wake() 向管道中写char唤醒后继续读mes。最好调用msg里的Handler处理。

Handler：是消息处理和分发的类。

处理消息时的函数。

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

若msg含有callback。会调用msg的callback处理msg的信息。可以参考Handler.post 族的函数处理方法。

如果msg没有callback，则会检查本身handler里的mCallback是否为空，一般情况都为空。

最后调用子类的handleMessage处理，可以参考handler.send 族的函数处理方法。

另外Handle可以绑定制定的looper。可以参考HanderThread.java 这个类，主要为developmentor 提供handler的处理looper。

Activity是一个UI线程，运行于主线程中，Android系统在启动的时候会为Activity创建一个消息队列和消息循环（Looper）。详细实现请参考ActivityThread.java文件。

Handler的作用是把消息加入特定的（Looper）消息队列中，并分发和处理该消息队列中的消息。构造Handler的时候可以指定一个Looper对象，如果不指定则利用当前线程的Looper创建即匹配到Acitivity的UI线程中。

一个Activity中可以创建多个工作线程或者其他的组件，如果这些线程或者组件把他们的消息放入Activity的主线程消息队列，那么该消息就会在主线程中处理了。因为主线程一般负责界面的更新操作，并且Android系统中的weget不是线程安全的，所以这种方式可以很好的实现Android界面更新。在Android系统中这种方式有着广泛的运用。

那么另外一个线程怎样把消息放入主线程的消息队列呢？答案是通过Handle对象，只要Handler对象以主线程的Looper创建，那么调用Handler的sendMessage等接口，将会把消息放入队列都将是放入主线程的消息队列。并且将会在Handler主线程中调用该handler的handleMessage接口来处理消息。

这里面涉及到线程同步问题，请先参考如下例子来理解Handler对象的线程模型：

1、首先创建MyHandler工程。

2、在MyHandler.java中加入如下的代码：

package com.simon;

import android.app.Activity;
import android.os.Bundle;
import android.os.Message;
import android.util.Log;
import android.os.Handler;

public class MyHandler extends Activity {
	static final String TAG = "Handler";
	Handler h = new Handler(){
    	public void handleMessage (Message msg)
    	{
    		switch(msg.what)
    		{
    		case HANDLER_TEST:
    			Log.d(TAG, "The handler thread id = " + Thread.currentThread().getId() + "\n");
    			break;
    		}
    	}
    };

	static final int HANDLER_TEST = 1;
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "The main thread id = " + Thread.currentThread().getId() + "\n");

        new myThread().start();
        setContentView(R.layout.main);
    }

    class myThread extends Thread
    {
    	public void run()
    	{
    		Message msg = new Message();
    		msg.what = HANDLER_TEST;
    		h.sendMessage(msg);
    		Log.d(TAG, "The worker thread id = " + Thread.currentThread().getId() + "\n");
    	}
    }
}

在这个例子中我们主要是打印，这种处理机制各个模块的所处的线程情况。如下是我的机器运行结果：

09-10 23:40:51.478: DEBUG/Handler(302): The main thread id = 1
09-10 23:40:51.569: DEBUG/Handler(302): The worker thread id = 8
09-10 23:40:52.128: DEBUG/Handler(302): The handler thread id = 1

我们可以看出消息处理是在主线程中处理的，在消息处理函数中可以安全的调用主线程中的任何资源，包括刷新界面。工作线程和主线程运行在不同的线程中，所以必须要注意这两个线程间的竞争关系。

上例中，你可能注意到在工作线程中访问了主线程handler对象，并在调用handler的对象向消息队列加入了一个消息。这个过程中会不会出现消息队列数据不一致问题呢？答案是handler对象不会出问题，因为handler对象管理的Looper对象是线程安全的，不管是加入消息到消息队列和从队列读出消息都是有同步对象保护的，具体请参考Looper.java文件。上例中没有修改handler对象，所以handler对象不可能会出现数据不一致的问题。

通过上面的分析，我们可以得出如下结论：

1、如果通过工作线程刷新界面，推荐使用handler对象来实现。

2、注意工作线程和主线程之间的竞争关系。推荐handler对象在主线程中构造完成（并且启动工作线程之后不要再修改之，否则会出现数据不一致），然后在工作线程中可以放心的调用发送消息SendMessage等接口。

3、除了2所述的hanlder对象之外的任何主线程的成员变量如果在工作线程中调用，仔细考虑线程同步问题。如果有必要需要加入同步对象保护该变量。

4、handler对象的handleMessage接口将会在主线程中调用。在这个函数可以放心的调用主线程中任何变量和函数，进而完成更新UI的任务。

5、Android很多API也利用Handler这种线程特性，作为一种回调函数的变种，来通知调用者。这样Android框架就可以在其线程中将消息发送到调用者的线程消息队列之中，不用担心线程同步的问题。

深入理解Android消息处理机制对于应用程序开发非常重要，也可以让你对线程同步有更加深刻的认识。

xcy2011sky

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
Android Framework分析 ---- 1消息处理机制 java层

在Android的系统中，无论是App层还是native层都有处理任务需要放在单独的线程处理。各个线程直接的协调处理需要消息传递和处理。本文主要介绍一下Android的消息传递和处理的机制。
复制链接

扫一扫