就是 示例代碼 pri 技術分享 android ble [] handle @override

在Android中主線程與子線程的通信十分重要，Google工程師為我們提供了Handler-Message機制來解決他們之間的交互問題。今天，我們就來簡單理解Handler-Message機制的原理，在Java中簡單模擬該機制。代碼示例Github地址HandlerDemo

首先，看一下簡單流程圖（不太專業）

由上圖可知，流程中主要相關類有Handler、Message、MessageQueue、Looper；下面，我們就圍繞它們來簡單分析該流程圖：

1.我們一般在主線程創建Handler，接著開啟子線程完成指定任務，再將任務數據封裝Message，交由Handler發出；

2.接著，MessageQueue接收Handler發來的Message，將其根據Message中的屬性when（時刻值）進行排序，重組隊列；

（在這插一段MessageQueue的由來：MessageQueue的創建其實是跟隨著Looper的創建，而Looper的一個特性就是一個線程只允許有一個Looper，緩存在ThreadLocal<Looper>中，而Looper的創建Looper.prepare()是要在創建Handler之前調用的，這 樣就保證了一個MessageQueue所緩存的隊列消息均是需要分發到該Looper所在線程的。）

3.接下來，通過Looper.loop()取出MessageQueue中的消息，而Looper.loop()以及MessageQueue中的next()均是堵塞線程的，所以和永動機一般，可以不停地取出消息；

4.最後，Looper.loop()取出的Message通過Message中的target（Handler）實現消息分發，而dispatchMessage(Message)方法為Handler中的方法，這樣就實現了“誰發出的消息誰處理”，所以一個線程中的多個Handler可以實現相對獨立的工作。

接下來，看一下示例代碼及其運行效果

代碼示例：

package com.wkp.test;

import android.wkp.Handler;
import android.wkp.Looper;
import android.wkp.Message;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

public class Main {

    public static void main(String[] args) {
        //主線程Looper準備
        Looper.prepareMainLooper();
        //創建Handler
        final MainHandler handler = new MainHandler();
        //開啟線程池
        Executor executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int position = i + 1;
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000 * position);
                        //子線程傳任務到主線程
                        handler.postDelayed(new Runnable() {
                            @Override
                            public void run() {
                                System.out.println(Thread.currentThread().getName() + " : " + position);
                            }
                        },1000);

                        Thread thread = Thread.currentThread();
                        //子線程傳消息到主線程
                        Message.obtain(handler,position,position,position,"主線程，你好！我是線程："+thread.getName()).sendToTarget();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        //消息隊列循環
        Looper.loop();
    }

    /**
     * 主線程處理子線程傳回的消息
     */
    private static class MainHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case WhatConstants.WHAT_ONE:
                    String obj1 = (String) msg.obj;
                    System.out.println(obj1);
                    break;
                case WhatConstants.WHAT_TWO:
                    String obj2 = (String) msg.obj;
                    System.out.println(obj2);
                    break;
                case WhatConstants.WHAT_THREE:
                    String obj3 = (String) msg.obj;
                    System.out.println(obj3);
                    break;
                case WhatConstants.WHAT_FOUR:
                    String obj4 = (String) msg.obj;
                    System.out.println(obj4);
                    break;
                case WhatConstants.WHAT_FIVE:
                    String obj5 = (String) msg.obj;
                    System.out.println(obj5);
                    break;
                case WhatConstants.WHAT_SIX:
                    String obj6 = (String) msg.obj;
                    System.out.println(obj6);
                    break;
                case WhatConstants.WHAT_SEVEN:
                    String obj7 = (String) msg.obj;
                    System.out.println(obj7);
                    break;
                case WhatConstants.WHAT_EIGHT:
                    String obj8 = (String) msg.obj;
                    System.out.println(obj8);
                    break;
                case WhatConstants.WHAT_NINE:
                    String obj9 = (String) msg.obj;
                    System.out.println(obj9);
                    break;
                case WhatConstants.WHAT_TEN:
                    String obj10 = (String) msg.obj;
                    System.out.println(obj10);
                    break;
            }
        }
    }
}
 

運行效果：

主線程，你好！我是線程：pool-1-thread-1
main : 1
主線程，你好！我是線程：pool-1-thread-2
main : 2
主線程，你好！我是線程：pool-1-thread-3
main : 3
主線程，你好！我是線程：pool-1-thread-4
主線程，你好！我是線程：pool-1-thread-5
main : 4
main : 5
主線程，你好！我是線程：pool-1-thread-6
主線程，你好！我是線程：pool-1-thread-7
main : 6
main : 7
主線程，你好！我是線程：pool-1-thread-8
main : 8
主線程，你好！我是線程：pool-1-thread-9
主線程，你好！我是線程：pool-1-thread-10
main : 9
main : 10

最後，歡迎親友們留言交流

如果大家想更深入的了解，可以觀看源碼Github地址，源碼中有詳盡的註釋。大家如果有更好的意見或建議以及好的靈感，請郵箱作者，謝謝！

QQ郵箱：[email protected]

163郵箱：[email protected]

Gmail郵箱：[email protected]

Java簡單模擬Android中Handler-Message機制