handler,message,looper,messagequeue

• 为什么Android要在主线程里更新UI

最根本的原因就是Android的开发团队想解决多线程并发问题。
如果在一个activity中不仅仅是主线程可以更新ui，而是每个线程都可以那么会出现出现ui更新混乱的局面，如果使用锁的问题来解决，那么又会导致效率的降低。
使用Handler机制，我们不用去考虑多线程的问题，所有更新UI的操作，都是在主线程消息队列中轮询去处理的。

• handler机制

• Handler封装了message的发送方法

• Looper

（1）Looper.prepare方法创建一个消息队列，即MessageQueue，所有Handler发送的消息都会进入这个队列

    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

（2）Looper.loop方法，是一个死循环，不断从MessageQueue取出消息，如有消息就处理，没有就阻塞

    /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final 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();
        //该方法的核心 死循环从消息队列中取消息
        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
        final Printer logging = me.mLogging;
        if (logging != null) {
            logging.println(">>>>> Dispatching to " + msg.target + " " +
                    msg.callback + ": " + msg.what);
        }

        final long traceTag = me.mTraceTag;
        if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
            Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
        }
        try {
            //获取的消息实际的处理，下面晚点分析
            msg.target.dispatchMessage(msg);
        } finally {
            if (traceTag != 0) {
                Trace.traceEnd(traceTag);
            }
        }

        if (logging != null) {
            logging.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(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.recycleUnchecked();
    }
    }

• MessageQueue，消息队列，可以添加消息，处理消息
• Handler内部会跟Looper进行关联，也就是说，在Handler内部可以找到Looper，找到了Looper也就找到了MessageQueue，在Handler中发送消息，其实就是向MessageQueue发送消息。

总结：Handler负责发送消息，Looper负责接收消息，并把消息回传给Handler自己，而MessageQueue是一个存储消息的容器。

• handler在主线程中应用

Android的应用程序是通过ActivityThread进行创建，在ActivityThread默认创建一个Main线程，一个Looper，所有更新UI的线程都是通过Main线程进行创建的。
在上面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的时候，会截获消息，没有的话会回调handleMessage()来处理消息。

• 在子线程中创建handler并接收消息

在子线程中创建Handler，需要通过Looper.prepare()获取Looper，且调用Looper.loop()方法对消息队列中的Message进行轮询

public class MainActivity extends AppCompatActivity {  
    private TextView mTextView;  
  
    public Handler mHandler = new Handler(){//主线程中的Handler  
        @Override  
        public void handleMessage(Message msg) {  
            Log.d("CurrentThread",Thread.currentThread()+"");//打印Thread 的ID  
        }  
    };  
  
    class MyThread extends Thread{  
        private Handler handler;//子线程中的Handler  
        @Override  
        public void run() {  
            Looper.prepare();//获取Looper  
            handler = new Handler(){  
                @Override  
                public void handleMessage(Message msg) {  
                    Log.d("CurrentThread",Thread.currentThread()+"");  
                }  
            };  
            Looper.loop();//轮询消息队列  
        }  
    }  
  
  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
  
        MyThread thread= new MyThread();  
        thread.start();  
        try {  
            thread.sleep(500);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        thread.handler.sendEmptyMessage(1);  
        mHandler.sendEmptyMessage(1);  
    }  
}  

有个例外的情况，虽然不影响我们开发，别说你不知道

public class MainActivity extends AppCompatActivity {  
TextView mTextView;  

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

    mTextView = (TextView) findViewById(R.id.tv);  

    new Thread(){  
        @Override  
        public void run() {  
            mTextView.setText("更新UI了");  
        }  
    }.start();  

}  
}  

上面的代码是可以成功运行的，只是我们的activity当前还没有来得及检测当前线程是否UI线程，所以可以直接成功更新ui，而在Activity的onResume()后是不可以的，但是ViewRootImpl类，因为在Activity中有一个ViewRootImpl类，这个类没有实例化的时候，系统不会检测当前线程是否UI线程，而这个类的实例化是在Activity的onResume（）中实现。

另外我们应该知道，一个Thead中可以建立多个Hander，通过msg.target保证MessageQueue中的每个msg交由发送message的handler进行处理 ，但是 每个线程中最多只有一个Looper，肯定也就一个MessageQuque。笔者在某次面试中是被问及过这个问题的