Handler发送消息的方式

方式1：使用 Handler.sendMessage（）

此处以 匿名内部类 的使用方式为例

步骤1：在主线程中 通过匿名内部类 创建Handler类对象

  private Handler mhandler = new  Handler(){
                @Override
                public void handleMessage(Message msg) {
                        ...// 需执行的UI操作
                    }
            };

  步骤2：创建消息对象 

Message msg = Message.obtain(); // 实例化消息对象
msg.what = 1; // 消息标识
msg.obj = "AA"; // 消息内容存放

  步骤3：在工作线程中 通过Handler发送消息到消息队列中

mHandler.sendMessage(msg);

  步骤4：开启工作线程（同时启动了Handler）

public class MainActivity extends AppCompatActivity {
    private Handler handler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case 1:
                    Toast.makeText(MainActivity.this, msg.obj.toString(), Toast.LENGTH_LONG).show();
                    break;
            }
        }
    };
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        sendMsg();
    }
 
    public void sendMsg() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(2000);//模拟一个耗时操作
 
                Message msg = new Message();
                msg.what = 1;//区分发送的消息
                msg.obj = "我是子线程发来的消息";
                handler.sendMessage(msg);
            }
        }).start();
 
    }
}

方式2：使用 Handler.post（）

 步骤1：在主线程中创建Handler实例

 private Handler mhandler = new mHandler();

与方式1的使用不同：此处无复写Handler.handleMessage() 

源码分析：

Handler的构造方法 作用：

 a. 在此之前，主线程创建时隐式创建Looper对象、MessageQueue对象

 b. 初始化Handler对象、绑定线程 & 进入消息循环

步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容 

需传入1个Runnable对象

  mHandler.post(new Runnable() {
            @Override
            public void run() {
                ... // 需执行的UI操作 
            }

    });

需传入1个Runnable对象、复写run()从而指定UI操作

源码分析：

 作用：定义UI操作、将Runnable对象封装成消息对象 & 发送 到消息队列中（Message ->> MessageQueue）

a. 相比sendMessage()，post（）最大的不同在于，更新的UI操作可直接在重写的run（）中定义

 b. 实际上，Runnable并无创建新线程，而是发送 消息 到消息队列中

步骤3：开启工作线程（同时启动了Handler）

分析：dispatchMessage(msg)
定义：属于处理者类（Handler）中的方法
作用：派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作

 public void dispatchMessage(Message msg) {

    // 1. 若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息（即此处需讨论的）
    // 则执行handleCallback(msg)，即回调Runnable对象里复写的run（）->> 分析2
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }

            // 2. 若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息（即此处需讨论的）
            // 则执行handleMessage(msg)，即回调复写的handleMessage(msg) 
            handleMessage(msg);

        }
    }

分析2：handleCallback(msg)

 private static void handleCallback(Message message) {
        message.callback.run();
        //  Message对象的callback属性 = 传入的Runnable对象
        // 即回调Runnable对象里复写的run（）
    }

至此，你应该明白使用 Handler.post（）的工作流程：与方式1（Handler.sendMessage（））类似，区别在于：

1. 不需外部创建消息对象，而是内部根据传入的Runnable对象 封装消息对象
2. 回调的消息处理方法是：复写Runnable对象的run（）

二者的具体异同如下：

 参考链接https://blog.csdn.net/carson_ho/article/details/80388560