Handler,Looper消息传递机制

   一、Handler消息传递机制初步认识：

（一）、引入：
        子线程没有办法对UI界面上的内容进行操作，如果操作，将抛出异常：CalledFromWrongThreadException
为了实现子线程中操作UI界面，Android中引入了Handler消息传递机制，目的是打破对主线程的依赖性。
        
 什么是Handler？
        handler通俗一点讲就是用来在各个线程之间发送数据的处理对象。在任何线程中，只要获得了另一个线程的handler，则可以通过  handler.sendMessage(message)方法向那个线程发送数据。基于这个机制，我们在处理多线程的时候可以新建一个thread，这个thread拥有UI线程中的一个handler。当thread处理完一些耗时的操作后通过传递过来的handler向UI线程发送数据，由UI线程去更新界面。 
        主线程：运行所有UI组件，它通过一个消息队列来完成此任务。设备会将用户的每项操作转换为消息，并将它们放入正在运行的消息队列中。主线程位于一个循环中，并处理每条消息。如果任何一个消息用时超过5秒，Android将抛出ANR。所以一个任务用时超过5秒，应该在一个独立线程中完成它，或者延迟处理它，当主线程空闲下来再返回来处理它。

（二）、常用类：（Handler、Looper、Message、MessageQueue）

Message：消息，其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。
Handler：处理者，负责Message的发送及处理。使用Handler时，需要实现handleMessage(Message
msg)方法来对特定的Message进行处理，例如更新UI等。Handler类的主要作用：（有两个主要作用）1）、在工作线程中发送消息；2）、在主线程中获取、并处理消息。
MessageQueue：消息队列，用来存放Handler发送过来的消息，并按照FIFO规则执行。当然，存放Message并非实际意义的保存，而是将Message串联起来的，等待Looper的抽取。
Looper：消息泵，不断地从MessageQueue中抽取Message执行。因此，一个MessageQueue需要一个Looper。
Thread：线程，负责调度整个消息循环，即消息循环的执行场所

（三）、Handler、Looper、Message、MessageQueue之间的关系：

Handler，Looper和MessageQueue的三角关系           Looper<-------------------------------MessageQueue |                                                   | |                                                   | |                                                   | |                                                   | |-------------->Handler<--------------|

                                                                                           

Looper和MessageQueue一一对应，创建一个Looper的同时，会创建一个MessageQueue；
而Handler与它们的关系，只是简单的聚集关系，即Handler里会引用当前线程里的特定Looper
4000
和MessageQueue；
在一个线程中，只能有一个Looper和MessageQueue，但是可以有多个Handler，而且这些Handler可以共享一个Looper和MessageQueue；
Message被存放在 MessageQueue中，一个 MessageQueue中可以包含多个Message对象。
【备注：】
Looper对象用来为一个线程开启一个消息循环，从而操作MessageQueue；
默认情况下，Android创建的线程没有开启消息循环Looper，但是主线程例外。
系统自动为主线程创建Looper对象，开启消息循环；
所以主线程中使用new来创建Handler对象。而子线程中不能直接new来创建Handler对象就会异常。
子线程中创建Handler对象，步骤如下：
Looper.prepare();
Handler handler = new Handler() {
    //handlemessage(){}

}
Looper.loop(); 

（四）、Handler类中常用方法：

handleMessage()    用在主线程中，构造Handler对象时，重写handleMessage()方法。该方法根据工作线程返回的消息标识，来分别执行不同的操作。
sendEmptyMessage()     用在工作线程中，发送空消息。
sendMessage()      用在工作线程中，立即发送消息。

（五）、Message消息类中常用属性：

arg1     用来存放整型数据
arg2      用来存放整型数据
obj        用来存放Object数据
what     用于指定用户自定义的消息代码，这样便于主线程接收后，根据消息代码不同而执行不同的相应操作。

【重点】：使用Message需要注意4点：
     1、Message虽然也可以通过new来获取，但是通常使用Message.obtain()或Handler.obtainMessage()方法来从消息池中获得空消息对象，以节省资源；
     2、如果一个Message只需要携带简单的int型数据，应优先使用arg1和arg2属性来传递数据，这样比其他方式节省内存；
     3、尽可能使用Message.what来标识信息，以便用不同的方式处理Message；
     4、如果需要从工作线程返回很多数据信息，可以借助Bundle对象将这些数据集中到一起，然后存放到obj属性中，再返回到主线程。
二、Handler、Looper源码分析：

（一）、Handler的概念：

Handler是用于发送和处理消息和一个线程的MessageQueue相关联的Runable对象。 
每个Handler实例关联到一个单一线程和线程的messagequeue。 
当您创建一个Handler,从你创建它的时候开始，它就绑定到创建它的线程以及对应的消息队列，handler将发送消息到消息队列，并处理从消息队列中取出的消息。

         Handler的主要用途有两个：

(1)、在将来的某个时刻执行消息或一个runnable；
(2)、为运行在不同线程中的多个任务排队。

实例代码一：(实现图片的轮播效果)

xml代码：
   

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:gravity="center">
    <ImageView
android:id="@+id/imageView"
        android:layout_width="200dp"
        android:layout_height="150dp" />
</LinearLayout>

java代码：

package com.zhidi.apple.handlerdemos;
import android.os.Handler;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.ImageView;
public class MainActivity extends AppCompatActivity  {
private Handler handler = new Handler();
private ImageView imageView;
private int images[] = {R.drawable.i, R.drawable.j, R.drawable.k};
private MyRunnable mMyrunnable = new MyRunnable();
private int Index;
class MyRunnable implements Runnable {
@Override
public void run() {
Index++;
int a = Index % 3;
imageView.[/b]setImageResource(images[a]);
handler.postDelayed(mMyrunnable, 1000);
}
    }
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
imageView = (ImageView) findViewById(R.id.imageView);
handler.postDelayed(mMyrunnable, 1000);
}
}

  效果 
 



主要依靠以下方法来完成消息调度：

post(Runnable)、 
postAtTime(Runnable, long)、 
postDelayed(Runnable, long)、 
sendEmptyMessage(int)、 
sendMessage(Message)、 
sendMessageAtTi(Message)、 
sendMessageDelayed(Message, long) 
【备注：】
post方法是当到Runable对象到达就被插入到消息队列； 
sendMessage方法允许你把一个包含有信息的Message插入消息队列，它会在Handler的handlerMessage(Message)方法中执行(该方法要求在Handler的子类中实现)。
当Handler post或者send消息的时候，可以在消息队列准备好的时候立刻执行，或者指定一个延迟处理或绝对时间对它进行处理，后两个是实现了timeout、ticks或者其他timing-based的行为。
当你的应用创建一个进程时，其主线程(UI线程)会运行一个消息队列，负责管理优先级最高的应用程序对象(Activity、广播接收器等)和任何他们创建的windows。你也可以创建自己的线程，通过handler与主线程进行通信，在新创建的线程中handler通过调用post或sendMessage方法，将传入的Runnable或者Message插入到消息队列中，并且在适当的时候得到处理。 

   
    （二）、Handler的用法：
当你实例化一个Handler的时候可以使用Callback接口来避免写自定义的Handler子类。这里的机制类似与Thread与runable接口的关系。
在Handler里面，子类要处理消息的话必须重写handleMessage()这个方法，因为在handler里面它是个空方法：
    
      
三）、源码分析：

A、Handler.java:（3个属性，5个方法）

三个属性：final MessageQueue mQueue;
final Looper mLooper;
final Callback mCallback;

五个方法：public boolean handleMessage(Message msg); 
public final Message obtainMessage()
public final boolean sendMessage(Message msg)
public final boolean sendEmptyMessage(int what)
public final boolean post(Runnable r)

B、Looper.JAVA:（4个属性，4个方法）
        每个ThreadLocal中只能有一个Looper，也就是说一个Thread中只有一个Looper

四个属性：    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    final MessageQueue  mQueue;
    final Thread  mThread;
    private static Looper mMainLooper = null;

四个方法：public static void prepare()
public static void prepareMainLooper()
public static void loop()
public static Looper myLooper()

C、Message.java:（5个属性，3个方法）

五个属性：public int what;
public int arg1;
public int arg2;
public Object obj;
Handler target; 

三个方法：public static Message obtain()
public void setTarget(Handler target)
public void recycle()