Handler

Handler的作用：
当我们需要在子线程处理耗时的操作（例如访问网络，数据库的操作），而当耗时的操作完成后，需要更新UI，这就需要使用Handler来处理，因为子线程不能做更新UI的操作。Handler能帮我们很容易的把任务（在子线程处理）切换回它所在的线程。简单理解，Handler就是解决线程和线程之间的通信的。

Handler的使用：
使用的handler的两种形式：
1.在主线程使用handler；
2.在子线程使用handler。

在主线程使用handler的示例

public class TestHandlerActivity extends AppCompatActivity {
 
 
        private static final String TAG = "TestHandlerActivity";
 
        private Handler mHandler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //获得刚才发送的Message对象，然后在这里进行UI操作
                Log.e(TAG,"------------> msg.what = " + msg.what);
            }
        };
 
 
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_handler_test);
            initData();
        }
 
        private void initData() {
 
            //开启一个线程模拟处理耗时的操作
            new Thread(new Runnable() {
                @Override
                public void run() {
 
                    SystemClock.sleep(2000);
                    //通过Handler发送一个消息切换回主线程（mHandler所在的线程）
                    mHandler.sendEmptyMessage(0);
                }
            }).start();
 
        }  

在主线程使用handler很简单，只需在主线程创建一个handler对象，在子线程通过在主线程创建的handler对象发送Message，在handleMessage（）方法中接受这个Message对象进行处理。通过handler很容易的从子线程切换回主线程了。

那么来看看在子线程中使用是否也是如此。

 public class TestHandlerActivity extends AppCompatActivity {
 
 
        private static final String TAG = "TestHandlerActivity";
 
        //主线程的Handler
        private Handler mHandler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                //获得刚才发送的Message对象，然后在这里进行UI操作
                Log.e(TAG,"------------> msg.what = " + msg.what);
            }
        };
        //子线程中的Handler
        private Handler mHandlerThread = null;
 
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_handler_test);
            initData();
        }
 
        private void initData() {
 
            //开启一个线程模拟处理耗时的操作
            new Thread(new Runnable() {
                @Override
                public void run() {
 
                    SystemClock.sleep(2000);
                    //通过Handler发送一个消息切换回主线程（mHandler所在的线程）
                    mHandler.sendEmptyMessage(0);
 
                    //调用Looper.prepare（）方法
                    Looper.prepare();
 
                    mHandlerThread = new Handler(){
                        @Override
                        public void handleMessage(Message msg) {
                            super.handleMessage(msg);
                            Log.e("sub thread","---------> msg.what = " + msg.what);
                        }
                    };
 
                    mHandlerThread.sendEmptyMessage(1);
 
                    //调用Looper.loop（）方法
                    Looper.loop();
                }
            }).start();
 
        }

可以看到，通过调用Looper.prepare()运行正常，handleMessage方法中就可以接收到发送的Message。

至于为什么要调用这个方法呢？去看看源码。

Handler的源码分析：
Handler的消息处理主要有五个部分组成，Message，Handler，Message Queue，Looper和ThreadLocal。首先简要的了解这些对象的概念

Message：Message是在线程之间传递的消息，它可以在内部携带少量的数据，用于线程之间交换数据。Message有四个常用的字段，what字段，arg1字段，arg2字段，obj字段。what，arg1，arg2可以携带整型数据，obj可以携带object对象。

Handler：它主要用于发送和处理消息的发送消息一般使用sendMessage（）方法,还有其他的一系列sendXXX的方法，但最终都是调用了sendMessageAtTime方法，除了sendMessageAtFrontOfQueue（）这个方法

而发出的消息经过一系列的辗转处理后，最终会传递到Handler的handleMessage方法中。

Message Queue：MessageQueue是消息队列的意思，它主要用于存放所有通过Handler发送的消息，这部分的消息会一直存在于消息队列中，等待被处理。每个线程中只会有一个MessageQueue对象。

Looper：每个线程通过Handler发送的消息都保存在，MessageQueue中，Looper通过调用loop（）的方法，就会进入到一个无限循环当中，然后每当发现Message Queue中存在一条消息，就会将它取出，并传递到Handler的handleMessage（）方法中。每个线程中只会有一个Looper对象。

ThreadLocal：MessageQueue对象，和Looper对象在每个线程中都只会有一个对象，怎么能保证它只有一个对象，就通过ThreadLocal来保存。Thread Local是一个线程内部的数据存储类，通过它可以在指定线程中存储数据，数据存储以后，只有在指定线程中可以获取到存储到数据，对于其他线程来说则无法获取到数据。

子线程创建Handler的两种方法

方式一: 获取主线程的looper(UI线程的looper---Looper.getMainLooper())

此方法是通过主线程的looper来实现的,简单使用.

new Thread(new Runnable() {
    @Override
    public void run() {
        Handler handler = new Handler(Looper.getMainLooper()) { //重点在此处
            @Override
            public void handleMessage(Message msg) {
                Toast.makeText(getApplicationContext(), "handler-msg", Toast.LENGTH_LONG).show();
            }
        };
        handler.sendEmptyMessage(1);
    }
}).start();

方式二: 直接获取当前子线程的looper

new Thread(() -> {
    Looper.prepare();
    @SuppressLint("HandlerLeak")
    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            Toast.makeText(getApplicationContext(), "handler-msg", Toast.LENGTH_LONG).show();
        }
    };
    handler.sendEmptyMessage(1);
    Looper.loop();
}).start();
或  new Thread(new Runnable() {

            @Override
            public void run() {
                Looper.prepare();
                Handler handler = new Handler(){
                    @Override
                    public void handleMessage(Message msg) {
                        Toast.makeText(getApplicationContext(), "handler-msg", Toast.LENGTH_LONG).show();
                    }
                };
                handler.sendEmptyMessage(1);
                Looper.loop();
            };
        }).start();