Handler 使用詳解

sihai 發布于2019-08-19 10:20 / 1096人閱讀

摘要：機制處理的個關鍵對象線程之間傳遞的消息，可以攜帶一些簡單的數據供子線程與主線程進行交換數據。解決方法子線程通過發送消息給主線程，讓主線程處理消息，進而更新。

極力推薦文章：歡迎收藏
Android 干貨分享

閱讀五分鐘，每日十點，和您一起終身學習，這里是程序員Android

本篇文章主要介紹 Android 開發中的部分知識點，通過閱讀本篇文章，您將收獲以下內容:

Handler 消息處理機制原理

Handler 機制處理的4個關鍵對象

Handler常用方法

子線程更新UI 異常處理

主線程給子線程發送消息的方法

子線程給主線程發送消息的方法

主、子線程互發消息方法

子線程方法中調用主線程更新UI的方法

Handler是 Android中用來更新UI 的一套消息處理機制。Handler 允許線程間發送Message或Runnable對象進行通信。在Android中UI修改只能通過UI Thread，子線程不能更新UI。如果子線程想更新UI，需要通過 Handler 發送消息給主線程，進而達到更新UI的目的。

Handler 簡介 繼承關系如下：

java.lang.Object
   ?    android.os.Handler

1. Handler 消息處理機制原理

當Android 應用程序創建的時候，系統會給每一個進程提供一個Looper ，Looper 是一個死循環，它內部維護一個消息隊列，Looper 不停的從消息隊列中取Message，取到的消息就發送給handler，最后Handler 根據接收的消息去修改UI等。

2. Handler 機制處理的4個關鍵對象 1.Message

線程之間傳遞的消息，可以攜帶一些簡單的數據供子線程與主線程進行交換數據。

2.Message Queue

存放通過Handler 發送的 Message 的消息隊列，每一個線程只有一個消息隊列。

3.Handler

消息處理者，主要用于發送跟處理消息。

主要功能：
發送消息SendMessage()
處理消息 HandleMessage()

4.Looper

內部包含一個死循環的MessageQueue，用于存儲handler 發送的Message，Looper則是不斷的從消息隊列中取消，如果有消息就取出發送給Handler 處理，沒有則阻塞。

總結：

Handler 負責發送Message到Message Queue，Looper負責從Message Queue 遍歷Message ,然后直接把遍歷的消息回傳給Handler 自己，通過Handler 自身的handleMessage處理更新UI等操作。

3. Handler常用方法 1.Runnable對象

post(Runnable)

使用方法舉例：

    public void BtnRunnableMethod(View view) {
        // 1.Runnable 對象
        RunnableHandlderMethod();
    }

    /**
     * Runnable 對象更新 UI 
     * **/
    private Handler mRunnableHandler = new Handler();
    public void RunnableHandlderMethod() {
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);

                    mRunnableHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            ((Button) findViewById(R.id.btn_runnable))
                                    .setText("Runnable");
                        }
                    });

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }.start();
    }

postAtTime(Runnable, long)

postDelayed(Runnable, long)

2. Message 對象

sendEmptyMessage(int)

使用方法舉例：

    public void BtnMessageThreadMethod(View view) {
        // 2.Message 對象
        new MessageHandlerThreadMethod("子線程不能更新UI").start();
    }
    /**
     * Message 對象舉例
     * ***/
    private int mCount = 0;
    private Handler mMessageHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            ((Button) findViewById(R.id.btn_thread)).setText("" + mCount);
        }
    };

    class MessageHandlerThreadMethod extends Thread {

        String mString;

        public MessageHandlerThreadMethod(String str) {
            mString = str;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {

                }

                mCount++;
                mMessageHandler.sendEmptyMessage(0);
            }

        }
    }

sendMessage(Message)

使用方法舉例：

public void BtnMessageObjMethod(View view) {
        HandlerMessageObjMethods();
    }

    /***
     * handler sendmessage 處理方法
     * **/
    private Handler mHandlerMessageObj = new Handler() {

        @Override
        public void handleMessage(Message msg) {

            ((Button) findViewById(R.id.btn_message)).setText("arg1:"
                    + msg.arg1 + "
" + msg.obj);
        }
    };

    private void HandlerMessageObjMethods() {
        new Thread() {
            @Override
            public void run() {

                try {
                    Thread.sleep(1000);
                    // Message message = new Message();
                    Message message = mHandlerMessageObj.obtainMessage();

                    message.arg1 = 100;

                    Person person = new Person();
                    person.name = "Lucy";
                    person.age = 12;

                    message.obj = person;
                    mHandlerMessageObj.sendMessage(message);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

    class Person {

        public int age;
        public String name;

        public String toString() {
            return "Name=" + name + "
 Age=" + age;
        }

    }

sendMessageAtTime(Message, long),

sendMessageDelayed(Message, long)

3.接收、處理Message

handleMessage(Message)

使用方法舉例：

    private Handler mMessageHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            ((Button) findViewById(R.id.btn_thread)).setText("" + mCount);
        }
    };

4. 子線程更新UI 異常處理

子線程不能更新UI，如果在子線程中更新UI，會出現CalledFromWrongThreadException 異常。

CalledFromWrongThreadException

解決方法：

子線程通過Handler 發送消息給主線程，讓主線程處理消息，進而更新UI。

5. 主線程給子線程發送消息的方法

此例子中子線程通過Looper不斷遍歷主線程發送的消息，Looper 使用方法如下：

準備Looper 輪詢器

Looper.prepare();

Handler 處理遍歷消息

Handler mHandler = new Handler()

遍歷消息隊列

Looper.loop();

Looper 使用方法如下：

    // 自定義 Loop 線程 ---> 不停的處理主線程發的消息
    class ChildLooperThread extends Thread {
        @Override
        public void run() {
            // 1.準備成為loop線程
            Looper.prepare();
            // 2.處理消息
            mMainHandler = new Handler() {
                // 處理消息
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                            ... ...
                        }
                    });
                }
            };
            // 3.Loop循環方法
            Looper.loop();
        }

    }

主線程發送消息給子線程的使用例子如下：

啟動子線程，并再啟動后發送消息

    public void BtnMainMessageMethod(View view) {
        // 點擊主線程 按鈕，啟動子線程，并在子線程啟動后發送消息
        Message msg = new Message();
        msg.obj = "主線程：這是我攜帶的信息";
        if (mMainHandler != null) {
            // 2.主線程發送消息
            mMainHandler.sendMessage(msg);
        } else {
            Toast.makeText(getApplicationContext(), "開啟子線程輪詢消息，請再次點擊發送消息",
                    Toast.LENGTH_SHORT).show();
            // 1.開啟輪詢線程，不斷等待接收主線成消息
            new ChildLooperThread().start();
        }
    }

子線程啟動，不停的變量主線程發送的消息

    private Handler mMainHandler;
    String mMainMessage;

    // 自定義 Loop 線程 ---> 不停的處理主線程發的消息
    class ChildLooperThread extends Thread {
        @Override
        public void run() {
            // 1.準備成為loop線程
            Looper.prepare();
            // 2.處理消息
            mMainHandler = new Handler() {
                // 處理消息
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    mMainMessage = (String) msg.obj;
                    Log.i("TAG", "子線程：從主線程中接受的消息為：
" + mMainMessage);
                    // 使用 runOnUiThread 在主線程中更新UI
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            ((Button) findViewById(R.id.btn_main_message))
                                    .setText(mMainMessage);
                        }
                    });
                }
            };
            // 3.Loop循環方法
            Looper.loop();
        }

    }

6. 子線程給主線程發送消息的方法

1.子線程發送消息給主線程方法

    public void BtnChildMessageMethod(View view) {

        new Thread() {
            public void run() {
                while (mCount < 100) {
                    mCount++;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    /**
                     * 利用handler 對象發送消息 Message msg=Message.obtain(); Message
                     * msg=new Message(); 獲取一個消息對象message
                     * */
                    Message msg = Message.obtain();
                    // 消息標記
                    msg.what = 1;
                    // 傳遞整型值msg.obj="傳遞object數據"
                    msg.arg1 = mCount;
                    Log.i("TAG", "count 值=" + mCount);
                    if (mhandler != null) {
                        mhandler.sendMessage(msg);
                    }
                }
            }
        }.start();
    }

2.主線程接收并處理消息的方法

// 定義一個handler 主線程 接收子線程發來的信息
    private Handler mhandler = new Handler() {
        // 處理消息的方法
        public void handleMessage(android.os.Message msg) {

            switch (msg.what) {
            case 1:
                int value = msg.arg1;
                Log.i("TAG", "value值=" + value);
                ((Button) findViewById(R.id.btn_child_message)).setText("當前值="
                        + value);
                break;

            default:
                break;
            }
        }

    };

7. 主、子線程互發消息方法

主要實現主、子線程每隔1s中通信一次

實現打印Log如下：

實現方法如下：

啟動子線程并發送給主線程消息

    public void BtnMainChildMessageMethod(View view) {

        // 創建 名稱為currentThread 子線程
        HandlerThread mChildThread = new HandlerThread("ChildThread");
        mChildThread.start();
        mChildHandler = new Handler(mChildThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {

                Log.i("TAG", "主線程對我說：" + msg.obj);

                // 子線程攜帶的消息
                Message message = new Message();
                message.obj = Thread.currentThread() + "我是子線程，小樣，讓我聽你的沒門";
                // 向主線程發送消息
                mainhandler.sendMessageDelayed(message, 1000);
            }
        };
        // 主線成發送空消息，開啟通信
        mainhandler.sendEmptyMessage(1);
    }

2.主線程接收并處理子線程發送的消息

    // 創建主線程
    private Handler mainhandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            Log.i("TAG", "子線程對我說：" + msg.obj);

            // 主線成攜帶的消息內容
            Message message = new Message();
            message.obj = Thread.currentThread() + "我是主線程：小子你得聽我的。";

            // 向子線程發送消息
            mChildHandler.sendMessageDelayed(message, 1000);
        }
    };

8.子線程方法中調用主線程更新UI的方法 Activity 中可以使用 runOnUiThread(Runnable)

                    // 使用 runOnUiThread 在主線程中更新UI
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            ((Button) findViewById(R.id.btn_main_message))
                                    .setText(mMainMessage);
                        }
                    });

子線程使用 Handler.post(Runnable)

                    mRunnableHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            ((Button) findViewById(R.id.btn_runnable))
                                    .setText("Runnable");
                        }
                    });

View.post()

                            ((Button) findViewById(R.id.btn_runnable)).post(new Runnable() {
                                
                                @Override
                                public void run() {
                                    // TODO Auto-generated method stub
                                    ((Button) findViewById(R.id.btn_runnable)).setText("View.post()方法使用");
                                }
                            });

Handler.sendMessage(Message)

    public void BtnMainMessageMethod(View view) {
        // 點擊主線程 按鈕，啟動子線程，并在子線程啟動后發送消息
        Message msg = new Message();
        msg.obj = "主線程：這是我攜帶的信息";
        if (mMainHandler != null) {
            // 2.主線程發送消息
            mMainHandler.sendMessage(msg);
            }
}

9.移除Handler 發送的消息方法

1.移除 handler 發送的所有消息

private Handler mChildHandler;
mChildHandler.removeCallbacksAndMessages(null);

2.移除指定消息

private Handler mainhandler;
mainhandler.removeMessages(what);

至此，本篇已結束，如有不對的地方，歡迎您的建議與指正。同時期待您的關注，感謝您的閱讀，謝謝！

GPU云服務器云服務器 android_handler詳解域名綁定與使用詳解 python字符串的使用詳解 iOS-GCD使用詳解

文章版權歸作者所有，未經允許請勿轉載,若此文章存在違規行為，您可以聯系管理員刪除。

轉載請注明本文地址：http://specialneedsforspecialkids.com/yun/75832.html

js事件詳解二：鼠標和滾輪事件

摘要：在級事件中定義了個鼠標事件，分別是。取消鼠標事件的默認行為還會影響其他事件，因為鼠標事件與其他事件是密不可分的關系。同樣的，和支持這個事件。兼容各個瀏覽器的事件監聽對象該對象封裝了和級事件的常用事件函數。概述鼠標事件是web開發中最常用的一類事件，畢竟鼠標還是最主要的定位設備。在DOM3級事件中定義了9個鼠標事件，分別是：click,dbclick,mousedown,mousee...

Lucky_Boy 2019-08-21 10:37 評論0 收藏0
Handler詳解

我們在new Handler()時候，實際上調用的是兩個參數的構造方法，我們看下 public Handler() { this(null, false); } public Handler(Callback callback, boolean async) { if (FIND_POTENTIAL_LEAKS) { fina...

Caizhenhao 2019-08-16 10:40 評論0 收藏0
js事件詳解

摘要：事件流事件流描述的是從頁面中接收事件的順序。其次，必須事先指定所有事件處理程序而導致的訪問次數，會延遲整個頁面的交互就緒時間。 1.事件流事件流描述的是從頁面中接收事件的順序。 1.1 事件冒泡 IE中的事件流叫做冒泡，即時間最開始由最具體的元素接收，然后逐級向上傳播到較為不具體的節點，直到傳播到document對象。例： Event Exampple ...

BDEEFE 2019-08-19 17:56 評論0 收藏0