记：Handler中知识点梳理

知识点1.Handler中重要的几个概念

主线程：应用程序第一次启动，会自动开启的一条线程。主要用来处理更新UI的操作。
子线程:程序手动开启的一条线程。主要用来执行一些耗时任务。
Message:线程间通信的数据单元。主要用于存储子线程要向主线程传递的数据内容
MessageQueue:消息队列，Handler存在的必要条件。主要用于存储Messge对象，是一种单链表形式，采用先进先出
Looper:循环器，MessageQueue与Handler的通信媒介,Handler存在的必要条件。主要用来循环从MessageQueue取出Message，并将Message分配给对应的Handler

知识点2.Handler 的流程图

Handler流程图.jpg

流程分析：Handler有两个作用，分别是发送消息和接收并处理消息。先从发送消息说·起，发送消息时，会将Message发送到MessageQueue队列中，Looper会不断循环从MessageQueue取出Message发送给对应的Handler，Handler接收传递过来的消息，并进项相应的逻辑处理。
由于Handler要发送Message，而Message需要存储到一个队列中才能得以保存，证明必须需要MessageQueue,而 MessageQueue并不是我们自己手动创建的，是Looper创建时候便会自动创建MessageQueue队列，且Handler 处理消息是由Looper进行分发，故我们知道了MessageQueue和Looper是Handler存在必要条件。

知识点3.创建Looper的两种方式：

(1)Looper.prepareMainLooper():在主线程当应用启动时，在main()执行。不需要我们手动调用。这就是为什么Handler我们可以直接写在主线程中，并进行处理UI相关逻辑。而在子线程我们就需要自己调用Looper
(1)Looper.prepare():在子线程当需要启动一个Handler，需在new Handler()之前先写Looper.prepare()，否则会报:

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

Handler必须绑定线程才能使用，而它绑定了Looper便会绑定Looper所在的线程。故必须有Looper,且Looper不能为空。

知识点4.MessageQueue和Looper之间的关系：

MessageQueue主要任务是用来存储Message,采用单链表的形式，先进先出的方式。
MessageQueue是什么时候创建的呢？
（１）进入Looper.prepare()

    public static void prepare() {
        prepare(true);
    }

（2）进入prepare()

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

（3）进入new Looper()，Looper的构造方法

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

至此会发现，Looper初始化便会创建一个对应的MessageQueue。
生成Looper和MessageQueue后，便会自动进入消息循环（Looper.loop()），当有消息便会进行操作，没有便会挂起。

知识点5.消息循环（Looper.loop()）：

    public static void loop() {
        final Looper me = myLooper();//分析点1
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;;//分析点2

        ...

        for (;;) {//分析点3
            Message msg = queue.next(); // might block      //分析点4
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

           ...

            try {
                msg.target.dispatchMessage(msg);//分析点5
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }

           ...

            msg.recycleUnchecked();
        }
    }

分析Looper.loop()中的源码，是如何开启的消息循环并把消息发给Handler?
分析点1:Looper me = myLooper(),进入 myLooper()->sThreadLocal.get(),此处Looper就是从ThreadLocal中获取(ThreadLocal:线程中的数据存储类，这里用于存储每个线程对应的Looper)
分析点2:MessageQueue是从Looper中获取的，每个Looper有一个对应MessageQueue
分析点3:这里是个死循环，不断从MessageQueue中获取待处理Message
分析点4:这里是个消息出队的操作，若MessageQueue不为空，就将此消息进行出队。若为空就会挂起Looper
分析点5：msg.target.dispatchMessage(msg);这里msg.target通过其它源码可知，指代的是Handler,将Message和Handler连在了一起,将消息分发给对应的handler，完成了消息的发送,dispatchMessage下一个知识点继续分析。

消息循环的操作 = 消息出队 + 分发给对应的Handler实例

知识点6.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 是否为空，不为空则是handler,post()方式（下面会说handler的两种方式），回调Runnable种重写的 run()
第二步：为空则是handler.sendMessage(message)方式，回调handleMessage（）

知识点7.handler的两种使用方法：

方法1
在子线程中调用，主线程中处理

 new Thread(new Runnable() {
     @Override
        public void run() {
            Message message=Message.obtain();
            message.what=1;
            message.obj="hello";
            handler1.sendMessage(message);
      }
});

    Handler handler1 = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    //更新UI
                    break;
            }
            return false;
        }
    });

这里涉及到一个知识点，Message的创建,有两种方式
（1） Message message=new Message();
（2） Message message=Message.obtain();
更推荐第二种方式通过源码查看,Message.obtain()方法中有一个线程池，如果线程池不为空，先是取出线程池中的线程，对其所有值赋值为空。属于线程的复用。避免了每次都new重新分配内存空间。

方法2
在主线程中创建Handler,然后直接调用即可

  Handler handler2 = new Handler();

  handler2.post(new Runnable() {
       @Override
       public void run() {
          //更新UI
       }
  });

发现handler.post（）方式并没有创建Message，它也并不是内部启动了一个线程。而是将Runnable封装成一个Message，也是传递到了MessageQueue，其余操作和流程便是一致了。

总结
(1)handler.post()不用创建外部Message；handler.sendMessage()需要传入Message
(2)两种方法的消息处理方式不同

两种handler方式.jpg

知识点8.一道面试题：主线程中Looper的轮询死循环为何没有阻塞主线程？

参考答案：Android是依靠事件驱动的，通过Loop.loop()不断进行消息循环，可以说Activity的生命周期都是运行在 Looper.loop()的控制之下，一旦退出消息循环，应用也就退出了。而所谓的导致ANR多是因为某个事件在主线程中处理时间太耗时，因此只能说是对某个消息的处理阻塞了Looper.loop()，反之则不然。

---

知识点9.新增：HandlerThread

HandlerThread：继承Thread,封装一个Handler
按顺序依次执行发送的Message

实现步骤：

1.声明初始化HandlerThread
2.线程开始 start()
3.初始化工作线程，new Handler(这里传参为HandlerThread中初始化的Looper)，所以此工作线程是子线程，不是主线程，不可以用来进行更新UI。重写handleMessage（）处理传递进来的消息
4.发送消息
5.线程关闭handlerThread.quit()

完整代码：

public class MainActivity extends AppCompatActivity {
    HandlerThread handlerThread;
    Handler mainHandler;
    Handler workHandler;


    private Button btFirst, btSecond,btQuit;
    private TextView tvMsg;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btFirst = (Button) findViewById(R.id.btFirst);
        btSecond = (Button) findViewById(R.id.btSecond);
        btQuit= (Button) findViewById(R.id.btQuit);
        tvMsg = (TextView) findViewById(R.id.tvMsg);

        mainHandler = new Handler();

        //1.初始化 名字自定义，用来标识线程
        handlerThread = new HandlerThread("myThread");
        //2.线程开始
        handlerThread.start();
        //3.绑定HandlerThread的线程,是thread子线程，所以不能进行更新ui操作
        workHandler = new Handler(handlerThread.getLooper()) {
            @Override
            public void handleMessage(final Message msg) {
                final String message = msg.obj.toString();
                switch (msg.what) {
                    case 1:
                        mainHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                tvMsg.setText(message);
                            }
                        });
                        break;
                    case 2:
                        mainHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                tvMsg.setText(message);
                            }
                        });
                        break;
                }
            }
        };
        //4.发message
        btFirst.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Message message = Message.obtain();
                message.what = 1;
                message.obj = "我是第一个按钮";
                workHandler.sendMessage(message);
            }
        });
        btSecond.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Message message = Message.obtain();
                message.what = 2;
                message.obj = "我是第二个按钮";
                workHandler.sendMessage(message);
            }
        });
        //5.停止
        btQuit.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                handlerThread.quit();
                //当handler被停止后，再调用sendMessage()会报：正在操作一个销毁了的handler，故之后不应在操作或操作之前加判断
            }
        });
    }
}

分享一篇Handler好文章：https://www.jianshu.com/p/b4d745c7ff7a