handler_looper机制，相互的关系和相互的信息传递过程详解

关于handler_loop机制：
1，什么是handlerloop机制：
handler_loop机制，准确的说是handler,message,messageQueuen,loop机制，因为他们当中，有两个是底层中的，所以，我们所操作的只有handler,和message这两个，为了实现子线程中操作UI界面，Android中引入了Handler消息传递机制，目的是打破对主线程的依赖性。
2，handler_loop机制的作用
因为大家都知道在子线程中无法对ui控件进行操作，会出现CalledFromWrongThreadException异常，
如果大量的数据操作在主线程中操作的话会因为长时间的等待排序，超过5秒，导致anr的出现会报错，所以，如何将子线程中的数据传递给主线程呢？在此，就可以通过handler机制进行操作。
3既然了解了这个机制，那么什么是handler呢？
handler,其实就是一个消息处理对象，他的作用就是将消息从一个线程，转移到另一个线程，（这里以主线程和子线程为例）；
只要你在子线程中，得到了主线程中的handler对象就可以通过handler.sendMessage的方法将数据转移到主线程，然后就可以进行操作了。
4，什么是Message.:
消息，被传递和处理的数据。其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。通俗的讲，就是handler要携带的数据。
5，什么是MessageQueue:


MessageQueue：消息队列，本质是一个数据结构，用来存放Handler发送过来的消息，并按照FIFO规则执行。当然，存放Message并非实际意义的保存，而是将Message串联起来，等待Looper的抽取。其实就是让传递过来的Messsage排队等待的地方。
6，什么是looper:
消息泵或循环器，不断从MessageQueue中抽取Message。因此，一个MessageQueue需要一个Looper。如果你把MessageQueue当做一个传送带的话，那么looper就是传送带终端接收处理产品的一个劳动者。接收获取。




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


【备注：】
Looper对象用来为一个线程开启一个消息循环，从而操作MessageQueue；
默认情况下，Android创建的线程没有开启消息循环Looper，但是主线程例外。
系统自动为主线程创建Looper对象，开启消息循环；
所以主线程中使用new来创建Handler对象。而子线程中不能直接new来创建Handler对象就会异常。
子线程中创建Handler对象，步骤如下：

Looper.prepare();

Handler handler = new Handler() {

    //handlemessage(){}

}

Looper.loop();

说了这么多现在再说一说消息传递的整个流程吧：（现附上一片代码）：

import android.app.Activity;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.PersistableBundle;

import com.yztc.mvpdemo.R;

/**
 * Created by Administrator on 2016/11/17.
 */
public class Activitys extends Activity {
//声明并创建handelr对象，用于子线程发送消息，并且用于主线程中接收消息
    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {//此处的参数就是接收到的消息对象
            super.handleMessage(msg);

//对消息对象进行判断
            switch (msg.what) {

//如果标签是0的话，就操作0，标签的handler发送的数据，因为一个可已有多个handelr,所以接受的是以标签是识别的
                case 0:

                    //此处将传递来的数据进行操作，用于更新ui;

                    break;
            }


        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);
        setContentView(R.layout.activity_main);
//创建子线程用于进行大量的耗时操作
        new Thread(new Runnable() {
            @Override
            public void run() {

//得到meddage对象，
                Message message = Message.obtain();

//打上标签
                message.what = 0;

//将需要传递出去的数据传递出去，
                message.obj = "呵呵，这里是子线程";

//发送消息
                handler.sendMessage(message);

            }
        }).start();

    }
}

整个流程就结束了，因为很多东西是在底层操作的，如果你不想深入了解，那么你看到这个地方就可以结束了

如果你想更加升入的了解一些底层的东西，可以继续向下看：

首先我先将handelr,looper,message,messageQoueue中的一些方法展示出来：

Handler类中常用方法：

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

Message消息类中常用属性：

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

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

    
    

     
     

      
      3个属性：
     
     
     
     

      
      
final MessageQueue mQueue;    封装好的Message被handler发送出去，其实就是放到了MessageQueue消息队列中。
final Looper mLooper;  每个handler都有一个looper为其不断接收消息队列中的消息，并返回给handler。
final Callback mCallback;    被handler接收到的消息要通过Callback接口中的handleMessage()方法来进行处理。
      
      

       
       

      
      
      
      

       
       10个方法：
      
      
     
     
     
     

      
      
public boolean handleMessage(Message msg);    Callback接口中的handleMessage()方法，用来处理返回给handler的消息的。
public final Message obtainMessage()     获取Message对象，其本质还是调用Message类的obtain()方法来获取消息对象。
public final boolean sendMessage(Message msg)      发送消息
public final boolean sendEmptyMessage(int what)      发送只有what属性的消息
public final boolean post(Runnable r)                          发送消息
public final boolean postAtTime(Runnable r, long uptimeMillis)         定时发送消息
public final boolean postDelayed(Runnable r, long delayMillis)         延迟发送消息
public void dispatchMessage(Message msg)                分发消息。当Looper循环接收消息队列中的消息时，就在不断调用handler的分发消息方法，从而触发Callback接口中的消息处理方法handleMessage()来对消息进行处理。
public final boolean sendMessageDelayed(Message msg, long delayMillis)     sendMessage()就是在调用延时发送消息的方法。
public boolean sendMessageAtTime(Message msg, long uptimeMillis)     延时发送消息的方法就是在调用定时发送消息的方法。
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)     将消息压入消息队列中
     
     
    
    

B、MessageQueue.JAVA: （1个方法）

•    final boolean enqueueMessage(Message msg, long when)    handler发送的消息正是通过该方法被加进了消息队列中。因为消息队列中有消息，从而触发了Looper通过loop()方法循环接收所有的消息。

C、Looper.JAVA: （3个属性，5个方法）

      
      

       
       3个属性：
      
      
      
      

       
       
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();   正是由于该线程本地变量，保证了一个线程中只能保存一个Looper对象，也就是说一个Thread中只能有一个Looper对象。
    final MessageQueue  mQueue;    正是由于MessagQueue中的消息，才触发了Looper的loop()方法。
    private static Looper mMainLooper = null;    该属性是主线程中自动创建的Looper对象。
       
       

        
        

       
       
       
       

        
        5个方法：
       
       
      
      
      
      

       
       
public static void prepare()            每个handler所在的线程都必须有一个Looper提前准备好。
public static void prepareMainLooper()         主线程中的的Looper已经被自动准备好。而该方法不需要手工调用。
public static Looper getMainLooper()            获取主线程中的Looper对象
public static void loop()                 Looper的作用就是循环接收消息队列中的消息。该方法中执行了一个无限循环。
public static Looper myLooper()       该方法的作用是从线程本地变量中获取到当前线程的Looper对象。
      
      

D、Message.java: （10个属性，7个方法）

      
      

       
       

        
        10个属性：
       
       
       
       

        
        

         
         
public int what;     该属性一般用来标识消息执行的状态。
public int arg1;     用来存放整型数据的属性。
public int arg2;     用来存放整型数据的属性。
public Object obj;    用来存放复杂消息数据的属性。
Bundle  data;          用来存放复杂消息数据的属性。
Handler target;       标识该消息要被发送给哪个Handler对象。
Message sPool;     消息池对象。
int sPoolSize;         记录消息池中剩余消息的数量。
int MAX_POOL_SIZE=50;     消息池中最大消息数量。
Messenger replyTo;        定义消息的信使对象，将来可以用于跨APP的消息传递。
        
        
        
        

         
         

        
        
        
        

         
         7个方法：
        
        
       
       
       
       

        
        
public static Message obtain()       从消息池中获取消息对象。
public void recycle()                      往消息池中归还消息对象。
public void setTarget(Handler target)           给消息handler对设置接收该消息的目标象。
public Handler getTarget()              获取消息的接收handler对象。
public void sendToTarget()             将消息发送到目标handler对象。其本质是调用handler对象的sendMessage()方法来发送当前消息对象。
public void setData(Bundle data)     将Bundle对象设置到message对象中Bundle属性中。
public Bundle getData()                   从消息对象中获取Bundle属性的数据。
       
       
      
      

先说一下信息传递的过程：（消息传递的执行顺序）

消息是如何从子线程中传递到主线程中的，中间发生了什么？

开始传递handler.sendmeddage（）---》调用的是底层的handler.sendMessageDelayed（）方法---》继续往底层深入handler.sendmessageAtTime()----->接着将消息传递给队列让队列进行管理handler.enquouoMessage()-------->消息队列接收到过来的消息messageQueue.enqueueMessage()--------->looper开始操作消息looper.loop()----->得到消息msg=messageQueue.next()------->分发消息msg.target.dispatchmessage(mdg)--------->msg的使命结束，开始进入回收被回收到了消息池中以供下次使用msg.recycle()----回收的同时----handlerMessage消息被传入到主线程，两者是几乎同时进行的这样整个消息传递结束，