Handler机制

旧城等待， 2022-07-13 08:21 234阅读 0赞

[聊一聊Android的消息机制][Android]

[Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系][Android _ _ Looper_Handler_Message]

[ Android异步消息处理机制完全解析，带你从源码的角度彻底理解][Android 1]

Handler：消息处理器，发送消息和处理消息  
Message：消息（数据载体）  
MessageQueue：消息队列（存储消息）  
Looper：轮询器，从messagequeue取消息，分发给handler处理

Activity#runOnUiThread(Runnable);
    View#post(Runnable);
    View#postDelayed(Runnable);

# **Activity\#runOnUiThread()的原理** #

public final void runOnUiThread(Runnable action) {
            if (Thread.currentThread() != mUiThread) {
                //1, mHandler.post(action);
                mHandler.post(action);
            } else {
                action.run();
            }
        }
    
        //1. mHandler.post(action);
        public final boolean post(Runnable r)
        {
            //2.sendMessageDelayed
            return  sendMessageDelayed(getPostMessage(r), 0);
        }
    
        //3getPostMessage(r)
        private final Message getPostMessage(Runnable r) {
            Message m = Message.obtain();
            m.callback = r;
            return m;
        }

# **Handler** #

<table> 
 <thead> 
  <tr> 
   <th align="left">方法声明</th> 
   <th align="left">功能描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">dispatchMessage(Message)</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">handleMessage()</td> 
   <td align="left">处理消息</td> 
  </tr> 
  <tr> 
   <td align="left">obtainMessage()</td> 
   <td align="left">获取消息</td> 
  </tr> 
  <tr> 
   <td align="left">removeCallbacks()</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">removeMessages()</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">removeCallBackAndMessage()</td> 
   <td align="left">移除所有的回调和消息</td> 
  </tr> 
  <tr> 
   <td align="left">sendMessage()</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">sendMessageDelayed()</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">sendMessageAtTime()</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">sendEmptyMessage()</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">sendEmptyMessageDelayed()</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">sendEmptyMessageAtTime()</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">post(Runnable)</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">postDelayed()</td> 
   <td align="left">延时任务，多少秒后执行</td> 
  </tr> 
  <tr> 
   <td align="left">postAtTime()</td> 
   <td align="left">定时任务，在什么时间执行</td> 
  </tr> 
 </tbody> 
</table>

public class Handler { 
        private Looper mLooper;
        private MessageQueue mQueue;
    
        public Handler(){
            mLooper = Looper.myLooper();
            if (mLooper == null){
                throw new RuntimeException("Can't create handler inside thread that has not called Looper.prepare()");
            }
            mQueue = mLooper.mQueue;
        }
    
        public void dispatchMessage(Message msg){
            handleMessage();
        }
    
        public void handleMessage(){
    
        }
    
        public boolean sendMessage(Message msg){
            return sendMessageDelayed(msg,0)
        }
    
        public boolean sendEmptyMessage(int what){
            return sendEmptyMessageDelayed(what,0);   
        }
    
        public boolean sendEmptyMessageDelayed(int what, long delayMillis){
            Message msg = Message.obtain();
            msg.what = what;
            return sendMessageDelayed(msg,0);
        }
    
        public boolean sendMessageDelayed(Message msg, long delayTime){
            if (delayTime < 0) delayTime = 0;
            return sendMessageAtTime(msg,SystemClock.uptimeMillis()+delayTime);
        }
    
        public boolean sendMessageAtTime(Message msg, long uptimeMillis){
            MessageQueue queue = mQueue;
            return enqueueMessage(queue,msg,uptimeMillis);
        }
    
        public boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis){
            msg.target = this;
            return queue.enqueueMessage(msg, uptimeMillis);
        }
    
        public void post(Runnable r){
            sendMessageDelayed(getPostMessage(r),0);
        }
    
        public static Message getPostMessage(Runnable r){
            Message m = Message.obtain();
            m.callback = r;
            return m;
        } 
    }

## **构造方法** ##

*  Handler()
 *  Handler(Callback callback)
 *  Handler(Looper looper)

public Handler(){
        ...
        mLooper = Looper.myLooper();
        if (mLooper == null){
            throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        ...
    }

当我们创建Handler的时候，构造函数完成的核心工作，从当前线程中获取Looper对象，然后获取MessageQueue对象，作为Handler的成员变量，等待着被使用

## **sendMessageAtTime()** ##

public boolean sendMessageAtTime(Message msg, long uptimeMillis)
    {
        ....
        // 把Message的target置为当前发送的Handler，以便Looper取到message后根据target把message分发给正确的Handler
        msg.target = this;
        // 往队列里面添加Message
        sent = queue.enqueueMessage(msg, uptimeMillis);
        ....
    }

## **dispatchMessage()** ##

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }
    
    //1.
    handleCallback(msg);
    
    //2.
    private final void handleCallback(Message message) {
        message.callback.run();//runnable 跟线程没关系
    }

## **主线程中Looper对象的创建时机** ##

//主线程设置Looper，在ActivityThread类（运行在主线程）里面
    public final class ActivityThread { 
        public static final void main (String[]args){
            ...
            // 1.主线程创建Looper 
            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();
        }
    }

## **ActivityThread** ##

public static void main(String[] args) {
            Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
            SamplingProfilerIntegration.start();
    
            // CloseGuard defaults to true and can be quite spammy. We
            // disable it here, but selectively enable it later (via
            // StrictMode) on debug builds, but using DropBox, not logs.
            CloseGuard.setEnabled(false);
    
            Environment.initForCurrentUser();
    
            // Set the reporter for event logging in libcore
            EventLogger.setReporter(new EventLoggingReporter());
    
            AndroidKeyStoreProvider.install();
    
            // Make sure TrustedCertificateStore looks in the right place for CA certificates
            final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
            TrustedCertificateStore.setDefaultUserDirectory(configDir);
    
            Process.setArgV0("<pre-initialized>");
    
            Looper.prepareMainLooper();
    
            ActivityThread thread = new ActivityThread();
            thread.attach(false);
    
            if (sMainThreadHandler == null) {
                sMainThreadHandler = thread.getHandler();
            }
    
            if (false) {
                Looper.myLooper().setMessageLogging(new
                        LogPrinter(Log.DEBUG, "ActivityThread"));
            }
    
            // End of event ActivityThreadMain.
            Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
            Looper.loop();
    
            throw new RuntimeException("Main thread loop unexpectedly exited");
        }

## **消息处理的优先级** ##

Message的callback > handler的Callback > Handler的handlerMessage()

mCallback：构造方法传进来的CallBack

## **内存泄露** ##

在使用Handler的时候，之前一直没有关心过，直到有一次发生了内存泄露才注意到这一点，在Activity销毁的时候要记得把handler的消息队列清空，或者在使用handler时，把handler设成静态变量或者弱引用。

onDestroy()中调用：removeCallbacks()，removeMessages()，removeCallbacksAndMessages()

private static class MyHandler extends Handler{ 
        private WeakReference<Activity> ref;
    
        public MyHandler(Activity activity){
            ref = new WeakReference<Activity>(activity);
        }
    
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Activity activity = ref.get();
            ...
        }
    }

## **标准的异步消息处理线程** ##

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

## Looper ##

public static final void prepareMainLooper() {
            prepare(); // 2、调用prepare
            setMainLooper(myLooper());
            if (Process.supportsProcesses()) {
                myLooper().mQueue.mQuitAllowed = false;
            }
        }

主线程调用Looper.loop()方法,主线程就会阻塞，是一个死循环，使用管道（Pipe），是Linux中的一种进程间通信方式，使用了特殊的文件，有两个文件描述符（一个是读取，一个是写入）

public static final void prepare() {
            if (sThreadLocal.get() != null) {
                throw new RuntimeException("Only one Looper may be created per thread");
            }
            // 3、在主线程中设置Looper， new Looper()里面创建了一个MessageQueue
            sThreadLocal.set(new Looper());
            // sThreadLocal类似HashMap8. }
        public static final void loop() {
            ...
            while (true) {
                // 取消息，如果没有消息，就阻塞
                Message msg = queue.next(); // might block
                ...
                msg.target.dispatchMessage(msg);
                ...
            }
        }

应用场景；主进程拿着读取描述符等待读取，没有内容时就阻塞，另一个进程拿写入描述符去写内容，唤醒主进程，主进程拿着读取描述符读取到内容，继续执行。

Handler应用场景：Handler在主线程中创建，Looper会在死循环里等待取消息，1、没取到，就阻塞，2、一旦被子线程唤醒，取到消息，就把Message交给Handler处理。子线程用Handler去发送消息，拿写入描述符去写消息，唤醒主线程。

Handler发送消息代码

public boolean sendMessageAtTime(Message msg, long uptimeMillis)
        {
            ....
            // 把Message的target置为当前发送的Handler，以便Looper取到message后根据target把message分发给正确的Handler
            msg.target = this;
            // 往队列里面添加Message
            sent = queue.enqueueMessage(msg, uptimeMillis);
            ....
        }

## MessageQueue.enqueueMessage() ##

final boolean enqueueMessage(Message msg, long when) {
        ...
        Message p = mMessages;
        if (p == null || when == 0 || when < p.when) {
            // 当前发送的message需要马上被处理调，needWake唤醒状态置true，入队其实就是将所有的消息按时间来进行排序
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked; // new head, might need to wake up
        } else {
            // 当前发送的message被排队到其他message的后面，needWake唤醒状态置false
            Message prev = null;
            while (p != null && p.when <= when) {
                prev = p;
                p = p.next;
            }
            msg.next = prev.next;
            prev.next = msg;
            needWake = false; // still waiting on head, no need to wake up
        }
    
        // 是否唤醒主线程
        if (needWake) {
            nativeWake(mPtr);
        }
        return true;
    }

## Handler.dispatchMessage() ##

public void dispatchMessage(Message msg) {
            if (msg.callback != null) {
                handleCallback(msg);
            } else {
                if (mCallback != null) {
                    if (mCallback.handleMessage(msg)) {
                        return;
                    }
                }
                // 把Message交给Handler处理
                handleMessage(msg);
            }
        }

Handler与Looper的关系：多对1，区分msg.target = this ;

MainThread 是Android 系统创建并维护的，创建的时候系统执行了Looper.prepare()方法，该方法内部创建了MessageQueue 消息队列（也叫消息池），该消息队列是Message 消息的容器

MainThread 拥有唯一的一个Looper 对象，该Looper 对象，拥有唯一的MessageQueue 对象，MessageQueue 对象可以存储多个Message。

MainThread 创建好之后，系统自动执行了Looper.loop()方法，该方法内部开启了一个“死循环”不断的去之前创建好的MessageQueue 中取Message。如果一有消息进入MessageQueue，那么马上会被Looper.loop()取出来，取出来之后就会调用之前创建好的handler 对象的handleMessage（Message）方法。

## Handler、Message、MessageQueue 、Looper ##

## Handler：handleMessage() ##

## Looper ##

在子线程中不能new Handler()，因为不能在没有调用Looper.prepare() 的线程中创建Handler

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

在构造方法中，创建了一个MessageQueue（消息队列）

private Looper(boolean quitAllowed) {
            mQueue = new MessageQueue(quitAllowed);
            mRun = true;
            mThread = Thread.currentThread();
        }
    
    
        public static final Looper myLooper() {
            return (Looper)sThreadLocal.get();
        }

## Looper.prepare() ##

Looper.prepare()方法不能被调用两次，一个线程中只有一个Looper实例

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

在程序启动的时候，系统已经帮我们自动调用了Looper.prepare()方法  
因此我们应用程序的主线程中会始终存在一个Looper对象，从而不需要再手动去调用Looper.prepare()方法了。  
在主线程中可以直接创建Handler对象，而在子线程中需要先调用Looper.prepare()才能创建Handler对象。  
Looper.loop(); 不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。

## Message、MessageQueue ##

MessageQueue消息队列，在Looper的构造函数中创建的，因此一个Looper也就对应了一个MessageQueue  
sendMessageAtTime(Message msg, long uptimeMillis)  
enqueueMessage()入队  
next()

## dispatchMessage(Message msg) ##

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

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

## post() ##

handler.post(new Runnable() {
            @Override
            public void run() {
                // 在这里进行UI操作 
            }
        });

在ActivityThread的main()方法中，会调用Looper.prepareMainLooper()方法

prepareMainLooper()里面会调用Looper.prepare()

prepare(){
            sThreadLocal.set(new Looper());//new Looper()里面创建了一个MessageQueue
        }
    
        looper创建完成后调用Looper.loop()
    
        loop(){
            while (true) {
                Message msg = queue.next();
                msg.target.dispatchMessage(msg);
            }
        }
    
        dispatchMessage(Message msg) {
            handleMessage(msg);// 把Message交给Handler处理
        }

Handler(){
            mLooper = Looper.myLooper();
            mQueue = mLooper.mQueue;
        }
    
        sendMessageAtTime(){
            //把Message的target置为当前发送的Handler，
            //以便Looper取到message后根据target把message分发给正确的Handler
            msg.target = this;
            // 往队列里面添加Message
            sent = queue.enqueueMessage(msg, uptimeMillis);
        }

让主线程给子线程发消息

# **HandlerThread** #

继承自Thread，在run()方法中，执行了Looper.prepare()和Looper.loop()，和handler结合使用，实现后台轮询线程功能

*  start()
 *  quit()
 *  getLooper()

public class HandlerThreadActivity extends AppCompatActivity { 
        private TextView      mTvServiceInfo;
        private HandlerThread mCheckMsgThread;
        private Handler       mCheckMsgHandler;
        private boolean       isUpdateInfo;
        private static final int MSG_UPDATE_INFO = 0x110;
    
        //与UI线程相关的handler
        private Handler mHandler = new Handler();
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_thread_handler);
            initBackThread();//创建后台线程
            mTvServiceInfo = (TextView) findViewById(R.id.id_textview);
        }
    
        @Override
        protected void onResume() {
            super.onResume();
            isUpdateInfo = true;//开始查询
            mCheckMsgHandler.sendEmptyMessage(MSG_UPDATE_INFO);
        }
    
        @Override
        protected void onPause() {
            super.onPause();
            isUpdateInfo = false;//停止查询
            mCheckMsgHandler.removeMessages(MSG_UPDATE_INFO);
        }
    
        private void initBackThread() {
            mCheckMsgThread = new HandlerThread("check-message-coming");
            mCheckMsgThread.start();
            mCheckMsgHandler = new Handler(mCheckMsgThread.getLooper()) {
                @Override
                public void handleMessage(Message msg) {
                    checkForUpdate();
                    if (isUpdateInfo) {
                        mCheckMsgHandler.sendEmptyMessageDelayed(
                                MSG_UPDATE_INFO, 1000);
                    }
                }
            };
        }
    
        //模拟从服务器解析数据
        private void checkForUpdate() {
            Thread.sleep(1000);//模拟耗时
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    String result = "msg";
                    mTvServiceInfo.setText(result);
                }
            });
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            mCheckMsgThread.quit();//释放资源
        }
    }

## HandlerThread源码 ##

Handler的构造，其实就是在Handler中持有一个指向该Looper.mQueue对象，当handler调用sendMessage方法时，其实就是往该mQueue中去插入一个message，然后Looper.loop()就会取出执行

public class HandlerThread extends Thread { 
        int mPriority;
        int mTid = -1;
        Looper mLooper;
    
        public HandlerThread(String name) {
            super(name);
            mPriority = Process.THREAD_PRIORITY_DEFAULT;
        }
    
        public HandlerThread(String name, int priority) {
            super(name);
            mPriority = priority;
        }
    
        protected void onLooperPrepared() {
        }
    
        @Override
        public void run() {
            mTid = Process.myTid();
            Looper.prepare();
            synchronized (this) {
                mLooper = Looper.myLooper();
                notifyAll();
            }
            Process.setThreadPriority(mPriority);
            onLooperPrepared();
            Looper.loop();
            mTid = -1;
        }
    
        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;
        }
    
        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;
        }
    
        public int getThreadId() {
            return mTid;
        }
    }

# **Looper** #

## 1. 源码 ##

public class Looper { 
        static final ThreadLocal<Looper> mThreadLocal = new InheritableThreadLocal<>();
        MessageQueue mQueue;
        Thread mCurrentThread;
        private static Looper sMainLooper;
    
        private Looper() {
            mQueue = new MessageQueue();
            mCurrentThread = Thread.currentThread();
        }
    
        public static void prepare() {
            if (mThreadLocal.get() != null) {
                throw new RuntimeException(
        "Only one Looper may be created per thread");
            }
            mThreadLocal.set(new Looper());
        }
    
        public void prepareMainLooper(){
            prepare();
            sMainLooper = myLooper();
        }
    
        public static void loop() {
            Looper me = myLooper();
            if (me == null) {
            throw new RuntimeException(
        "No Looper; Looper.prepare() wasn't called on this thread.");}
        MessageQueue queue = me.mQueue;
            for(;;){
                Message msg = queue.next();//block
                msg.target.dispatchMessage(msg);
            }
        }
    
        public static Looper myLooper() {
            return mThreadLocal.get();
        }
    }

## 2. Field ##

MessageQueue  mqueue
    ThreadLocal  sThreadLocal
    Looper  sMainLooper

## 3. 构造方法 ##

创建了消息队列
    获得当前线程

## 4. prepare() ##

public static final void prepare() {
            if (sThreadLocal.get() != null) {
                throw new RuntimeException("Only one Looper may be created per thread");
            }
            // 3、在主线程中设置Looper， new Looper()里面创建了一个MessageQueue
            sThreadLocal.set(new Looper());
    
        public static final void prepareMainLooper() {
            // 2、调用prepare
            prepare();
            setMainLooper(myLooper());
            if (Process.supportsProcesses()) {
                myLooper().mQueue.mQuitAllowed = false;
            }
        }

sThreadLocal.get()从Threadlocal获取Looper，如果不为空则抛异常，因为一个线程只能有一个Looper，如果当前线程的Looper为空，则创建一个Looper对象，并且把Looper对象set给sThreadLocal

## 5. 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) {
                        // No target is a magic identifier for the quit message.
                        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);
    
                    // 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("Looper", "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.recycle();
                }
            }
        }

调用myLooper()方法，从sThreadlocal获取当前线程的Looper对象，并且从looper对象获取MessageQueue  
开启死循环，调用MessageQueue的next()方法从消息队列取消息，当消息队列没有消息的时候该方法会阻塞  
取到消息后，调用msg.target.dispatchMessage()方法处理该消息，msg.target就是handler对象，也就是从消息队列取到消息后，就会调用handler的dispatchMessage()方法处理消息，而dispatchMessage()里面会调用handleMessage()方法，也就是我们创建handler时实现的handleMessage()方法，在该方法中处理消息

## 6. myLooper() ##

从sThreadLocal获取当前线程的looper对象

## 7. prepareMainLooper() ##

为主线程创建looper对象，先调用prepare()方法，再调用myLooper()获取looper对象

## 8. MessageQueue ##

## 9. Message ##

Handler  target
    Runnable  callback
    Object  obj
    int  what

## 9.1. Message上限 ##

Message.obtain的消息池上限是50个  
private static final int MAX\_POOL\_SIZE = 50;

# **Message** #

## 方法 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">方法声明</th> 
   <th align="left">功能描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">obtain()</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">setData(Bundle data)</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">sendToTarget()</td> 
   <td align="left"></td> 
  </tr> 
 </tbody> 
</table>

## 属性 ##

<table> 
 <thead> 
  <tr> 
   <th align="left">属性声明</th> 
   <th align="left">功能描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">int what</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">Object obj</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">Messenger replyTo</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">Runnable callback</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">Handler target</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">long when</td> 
   <td align="left"></td> 
  </tr> 
 </tbody> 
</table>

Message msg = new Message();
    Message msg = handler.obtainMessage();
    Message msg = Message.obtain()
    Message.obtain(handler, what, obj).sendToTarget();
    msg.obj = "data";
    msg.what = 1;
    msg.setData(Bundle);
    msg.sendToTarget();

# **Messenger** #

# 让主线程给子线程发送消息 #

public class MainActivity extends Activity { 
    
        private Handler subHandler;//是在子线程中创建的Handler对象
        private Looper myLooper;//子线程中的Looper对象
    
        private Handler handler = new Handler(){
            @Override
            public void handleMessage(android.os.Message msg) {
                switch (msg.what) {
                case 1:
    
                    Toast.makeText(MainActivity.this, msg.obj.toString(), Toast.LENGTH_SHORT).show();
    
                    break;
    
                default:
                    break;
                }
            };
        };
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            /* * 匿名内部类对象对外部类有一个隐式的强引用 */
            new Thread(new Runnable() {
    
    
                @Override
                public void run() {
                    /* * 1. 创建了Looper对象，然后Looper对象中创建了MessageQueue * 2. 并将当前的Looper对象跟当前的线程（子线程）绑定ThreadLocal */
                    Looper.prepare();
    
                    /* * 1. 创建了handler对象，然后从当前线程中获取Looper对象，然后获取到MessageQueue对象 */
    
                    subHandler = new Handler(){
                        @Override
                        public void handleMessage(Message msg) {
    
                            Toast.makeText(MainActivity.this, msg.obj.toString(), Toast.LENGTH_SHORT).show();
    
                        }
                    };
                    //获取当前线程中的Looper对象
                    myLooper = Looper.myLooper();
    
    
                    /* * 1. 从当前线程中找到之前创建的Looper对象，然后找到 MessageQueue * 2. 开启死循环，遍历消息池中的消息 * 3. 当获取到msg的时候，调用这个msg的handler的disPatchMsg方法，让msg执行起来 */
                    Looper.loop();
                    Log.d("tag", "loop()方法执行完了");
                }
            }).start();
    
        }
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
            if (myLooper!=null) {
                myLooper.quit();
                myLooper = null;
            }
    
        }
    
        public void sendMsg(View view){
    
            new Thread(new Runnable() {
    
                @Override
                public void run() {
    
                    SystemClock.sleep(2000);//模拟一个耗时操作
    
                    Message msg = new Message();
                    msg.what = 1;//区分发送的消息
                    msg.obj = "来自子线程的问候";
    
    
                    handler.sendMessage(msg);
    
    
                }
            }).start();
    
        }
    
        public void sendMsg2(View view) {
    
            //从消息池中获取一个旧的msg，如果没有重新创建消息
            subHandler.obtainMessage(2, "我是主线程发送来的祝福").sendToTarget();
    
        }
    }

[Android]: https://my.oschina.net/youranhongcha/blog/492591
[Android _ _ Looper_Handler_Message]: http://blog.csdn.net/lmj623565791/article/details/38377229/
[Android 1]: http://blog.csdn.net/guolin_blog/article/details/9991569