[Android]Handler的消息机制

最经面试中，技术面试中有一个是Handler的消息机制，细细想想，我经常用到的Handler无非是在主线程（或者说Activity）新建一个Handler对象，另外一个Thread是异步加载数据，同时当他加载完数据后就send到主线程中的那个Handler对象，接着Handler来处理，刚才发送的一些消息。

 public class HandlerTestActivity extends Activity {
     private TextView tv;
     private static final int UPDATE = 0;
     private Handler handler = new Handler() {

         @Override
         public void handleMessage(Message msg) {
             // TODO 接收消息并且去更新UI线程上的控件内容
             if (msg.what == UPDATE) {
                 // Bundle b = msg.getData();
                 // tv.setText(b.getString("num"));
                 tv.setText(String.valueOf(msg.obj));
             }
             super.handleMessage(msg);
         }
     };

     /** Called when the activity is first created. */
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.main);
         tv = (TextView) findViewById(R.id.tv);

         new Thread() {
             @Override
             public void run() {
                 // TODO 子线程中通过handler发送消息给handler接收，由handler去更新TextView的值
                 try {
                     for (int i = 0; i < 100; i++) {
                         Thread.sleep(500);
                         Message msg = new Message();
                         msg.what = UPDATE;
                         // Bundle b = new Bundle();
                         // b.putString("num", "更新后的值：" + i);
                         // msg.setData(b);
                         msg.obj = "更新后的值：" + i;
                         handler.sendMessage(msg);
                     }
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }.start();
     }

 }

如图所示，每个Thread都一个Looper，这个Looper类是用于管理其中的消息队列（MessageQueue）的,那Handler是干嘛的呢，他是用来传递消息队列的。

那下面就分析Looper、Hanlder方法吧。

Looper方法是用来处理消息队列的，注意了，它和线程是绑定的。

要是想在子线程中获取一个Looper该怎么做呢：

    Looper.prepare();
    Looper looper = Looper.myLooper();

那么这些都干了哪些工作呢???

来看下它的源码吧:

Looper:

……

//准备Looper相关事宜
   public static void prepare() {
     //只能有一个对象哦
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
         sThreadLocal.set(new Looper());
     }
   //构造函数
  /*新建一个消息队列
   * 把当前运行的线程作为运行线程
  */

    private Looper() {
        mQueue = new MessageQueue();
        mRun = true;
        mThread = Thread.currentThread();
    }

public static final Looper myLooper() {

//这个方法是从当前线程的ThreadLocal中拿出设置的looper

return (Looper)sThreadLocal.get();

}

/**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    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;

        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

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

                long wallStart = 0;
                long threadStart = 0;

                // 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);
                    wallStart = SystemClock.currentTimeMicro();
                    threadStart = SystemClock.currentThreadTimeMicro();
                }

                msg.target.dispatchMessage(msg);

                if (logging != null) {
                    long wallTime = SystemClock.currentTimeMicro() - wallStart;
                    long threadTime = SystemClock.currentThreadTimeMicro() - threadStart;

                    logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
                    if (logging instanceof Profiler) {
                        ((Profiler) logging).profile(msg, wallStart, wallTime,
                                threadStart, threadTime);
                    }
                }

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

下面就来看下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());
            }
        }
      //先获得一个Looper对象，这个要是在子线程里，是需要先prepare（）的

        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;
    }
  /**
     * Returns a new {@link android.os.Message Message} from the global message pool. More efficient than
     * creating and allocating new instances. The retrieved message has its handler set to this instance (Message.target == this).
     *  If you don't want that facility, just call Message.obtain() instead.
   会从消息池里面取得消息队列
     */
    public final Message obtainMessage()
    {
        return Message.obtain(this);
    }

那我现在写个小例子，是在子线程实现的消息的传递。

@Override
    public void onClick(View v) {
        int id = v.getId();
        if (id == R.id.btn1) {
            new Thread() {

                public void run() {

                    Log.i("log", "run");

                    Looper.prepare();
                    // Looper looper = Looper.myLooper();
                    Toast.makeText(MainActivity.this, "toast", 1).show();
                    Handler h = new Handler() {

                        @Override
                        public void handleMessage(Message msg) {
                            // TODO Auto-generated method stub
                            super.handleMessage(msg);
                            if (msg != null) {
                                String strMsg = (String) msg.obj;
                                System.out.println(strMsg);
                            }

                        }

                    };
                    //获取到Handler对象的消息
                    Message msg = h.obtainMessage();
                    msg.obj = "add";
                    msg.sendToTarget();

                    Looper.loop();// 进入loop中的循环，查看消息队列

                };

            }.start();

        }
    }

不知你是否理解，这个小Demo中，我们需要注意：

1  子线程也是可以有Handler的，其实Handler只是从当前的线程中获取到Looper来监听和操作MessageQueue的。

2 子线程需要先prepare（）才能获取到Looper的，是因为在子线程只是一个普通的线程，其ThreadLoacl中没有设置过Looper，所以会抛出异常，而在Looper的prepare（）方法中sThreadLocal.set(new Looper())是设置了Looper的。

而对于主线程里面的Handler，是没有以上的麻烦的，因为这个在Activity创建时，就已经初始化了Looper等其他工作了。

另外可以看下参考文章中的子线程中Toast。

参考文章：

Android之Handler用法总结

Android Handler机制

子线程中Toast