欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

詳解Android的Handler機制原理

 更新時間：2023年10月31日 11:08:19   作者：淘淘養(yǎng)樂多  
Android的Handler機制是一種用于處理和調度線程之間消息傳遞的機制,通常用于在后臺線程中執(zhí)行任務,并將結果返回到主線程中更新UI,Handler機制的核心是Message和MessageQueue,以及Looper,本文給大家詳細講解了Android的Handler機制原理,需要的朋友可以參考下

以下是Android Handler機制的主要組成部分和工作原理：

1.Message（消息）：Message是一個包含要傳遞的數(shù)據(jù)和指令的對象。它可以攜帶整數(shù)、字符串、Bundle等不同類型的數(shù)據(jù)。當需要在不同線程之間傳遞數(shù)據(jù)或執(zhí)行任務時，通常會創(chuàng)建一個Message并將其發(fā)送給Handler。

2.Handler（處理程序）：Handler是用于處理Message的對象。它通常與一個特定的線程（通常是主線程）關聯(lián)。通過Handler，您可以將Message發(fā)送到與其關聯(lián)的線程的消息隊列中，以便在那個線程中執(zhí)行處理。

3.Looper（消息循環(huán)器）：Looper是一個用于管理線程的消息隊列的對象。每個線程都可以有一個Looper，它會在線程上創(chuàng)建一個消息隊列，允許該線程接收并處理Message。主線程通常已經(jīng)具有一個默認的Looper，而后臺線程需要顯式創(chuàng)建一個Looper。

4.MessageQueue（消息隊列）：MessageQueue是一個FIFO（先進先出）隊列，用于存儲待處理的Message。每個Looper都有一個關聯(lián)的MessageQueue，Handler將Message發(fā)送到這個隊列中，然后由Looper依次處理隊列中的Message。

Handler機制的工作流程：

1.在主線程（或其他線程）上創(chuàng)建一個Handler對象，這個Handler會關聯(lián)到當前線程的Looper。

2.在后臺線程中，創(chuàng)建一個Message對象，可以將一些數(shù)據(jù)和處理指令放入這個Message。

3.使用Handler的sendMessage方法將Message發(fā)送到與Handler關聯(lián)的Looper的MessageQueue中。

4.Looper在后臺線程中不斷輪詢MessageQueue，當有新的Message到達時，將Message取出并交給Handler處理。

5.Handler收到Message后，可以根據(jù)Message中的指令執(zhí)行相應的操作，通常是在主線程中更新UI。

6.如果需要定時任務或循環(huán)執(zhí)行，可以使用Handler的postDelayed方法。

Handler 的三種使用方法，分別是：

Handler.sendMessage(Message)

Handler.post(Runnable)

Handler.obtainMessage(what).sendToTarget();

1. Handler.sendMessage()方法

Handler.sendMessage(Msg) 方法是最為常見的一種方法。

1.1 使用步驟說明

其使用步驟分四步，如下所示：

1、步驟一：新建 Handler 對象，覆寫 handleMessage(Message) 方法。

2、步驟二：新建 Message 對象，設置其攜帶的數(shù)據(jù)。

3、步驟三：在子線程中通過 Handler.sendMessage(Message) 方法發(fā)送信息。

4、步驟四：在 Handler 的 handleMessage(Message msg) 方法中處理消息，通知主線程作出相對應的 UI 工作。

步驟一：新建 Handler 對象，覆寫 handleMessage(Message) 方法

//創(chuàng)建 Handler對象，并關聯(lián)主線程消息隊列
mHandler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
            ···略···
        }
    }
};

步驟二：新建 Message 對象，設置其攜帶的數(shù)據(jù)

Bundle bundle = new Bundle();
bundle.putInt(CURRENT_PROCESS_KEY, i);
Message msg = new Message();
msg.setData(bundle);
msg.what = 2;

步驟三：在子線程中通過 Handler.sendMessage(Message) 方法發(fā)送信息

mHandler.sendMessage(msg)

步驟四：在 Handler 的 handleMessage(Message msg) 方法中處理消息，通知主線程作出相對應的 UI 工作

mHandler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
        super.handleMessage(msg);
        //根據(jù)信息編碼及數(shù)據(jù)做出相對應的處理
        switch (msg.what) {
            case 1:
                //更新 TextView UI
                mDisplayTv.setText("CustomChildThread starting!");
                break;
            case 2:
                //獲取 ProgressBar 的進度，然后顯示進度值
                Bundle bundle = msg.getData();
                int process = bundle.getInt(CURRENT_PROCESS_KEY);
                mProgressBar.setProgress(process);
                break;
            default:
                break;
        }
    }
};

1.2.1Java版本的具體代碼如下所示:

public class HandlerAddThreadActivity extends AppCompatActivity {
    public static final String CURRENT_PROCESS_KEY = "CURRENT_PROCESS";
    private TextView mDisplayTv;
    private Handler mHandler;
    private ProgressBar mProgressBar;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_add_thread);

        TextView titleTv = findViewById(R.id.title_tv);
        titleTv.setText("Handler + Thread");
        
        mDisplayTv = findViewById(R.id.display_tv);
        mProgressBar = findViewById(R.id.test_handler_progress_bar);

        //mHandler用于處理主線程消息隊列中的子線程消息
        mHandler = new Handler(Looper.getMainLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                switch (msg.what) {
                    case 1:
                        //更新 TextView UI
                        mDisplayTv.setText("CustomChildThread starting!");
                        break;
                    case 2:
                        //獲取 ProgressBar 的進度，然后顯示進度值
                        Bundle bundle = msg.getData();
                        int process = bundle.getInt(CURRENT_PROCESS_KEY);
                        mProgressBar.setProgress(process);
                        break;
                    default:
                        break;
                }

            }
        };
        
        Button mClickBtn = findViewById(R.id.click_btn);
        mClickBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //開啟子線程，子線程處理UI工作
                CustomChildThread customThread = new CustomChildThread();
                customThread.start();
            }
        });
    }

    /**
     * 子線程，用于處理耗時工作
     */
    public class CustomChildThread extends Thread {

        @Override
        public void run() {
            //在子線程中創(chuàng)建一個消息對象
            Message childThreadMessage = new Message();
            childThreadMessage.what = 1;
            //將該消息放入主線程的消息隊列中
            mHandler.sendMessage(childThreadMessage);

            //模擬耗時進度，將進度值傳給主線程用于更新 ProgressBar 進度。
            for (int i = 1; i <= 5; i++) {
                try {
                    //讓當前執(zhí)行的線程（即 CustomChildThread）睡眠 1s
                    Thread.sleep(1000);

                    //Message 傳遞參數(shù)
                    Bundle bundle = new Bundle();
                    bundle.putInt(CURRENT_PROCESS_KEY, i);
                    Message progressBarProcessMsg = new Message();
                    progressBarProcessMsg.setData(bundle);
                    progressBarProcessMsg.what = 2;
                    mHandler.sendMessage(progressBarProcessMsg);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1.2.2Kotlin版本的代碼如下所示：

class TestThreadAddHandlerActivity : AppCompatActivity() {
    companion object {
        const val PROGRESS_VALUE_KEY = "PROGRESS_VALUE"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_thread_add_handler)

        handlerAddThreadStartBtn.setOnClickListener(View.OnClickListener {
            //工作線程開始模擬下載任務
            val workThread: WorkThread = WorkThread(this)
            workThread.start()
        })
    }

    class WorkThread(activity: TestThreadAddHandlerActivity) : Thread() {
        private var handler: MyHandler = MyHandler(activity)

        override fun run() {
            super.run()
            for (i in 0..6) {
                sleep(1000)
                //通過 Handler 將進度參數(shù)傳遞給 主線程，讓其更新 progressBar 進度
                val message = Message()
                message.what = 1
                val bundle = Bundle()
                bundle.putInt(PROGRESS_VALUE_KEY, i)
                message.data = bundle
                handler.sendMessage(message)
            }
        }
    }

    /**
     * 靜態(tài)內部類，防止內存泄漏
     */
    class MyHandler(activity: TestThreadAddHandlerActivity) : Handler() {
        private var weakReference = WeakReference(activity)

        override fun handleMessage(msg: Message) {
            super.handleMessage(msg)
            //處理消息
            when (msg.what) {
                1 -> {
                    val activity = weakReference.get()
                    if (activity != null && !activity.isFinishing) {
                        //獲取消息中攜帶的任務處理進度參數(shù)，然后設置成 ProgressBar 的進度。
                        val progressValue: Int = msg.data.get(PROGRESS_VALUE_KEY) as Int
                        activity.handlerAddThreadProgressBar.progress = progressValue
                    }
                }
            }
        }
    }
}

2. Handler.post()方法

除了使用 Handler.sendMessage(Message) 來發(fā)送信息，Handler 還支持 post(Runnable) 方法來傳遞消息，通知主線程做出相對應的 UI 工作。使用方法如下：

/**
 * 將可運行的 Runnable 添加到消息隊列。Runnable 將在該 Handler 相關的線程上運行處理。
 * The runnable will be run on the thread to which this handler is attached.
 */
new Handler().post(new Runnable() {
    @Override
    public void run() {
        //更新處理 UI 工作
    }
});

2.1 Java版本的具體代碼如下

public class HandlerPostFunctionActivity extends AppCompatActivity {
    private Handler mMainHandler;
    private ProgressBar mProgressBar;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_add_thread);

        TextView titleTv = findViewById(R.id.title_tv);
        titleTv.setText("Handler post() function");

        mProgressBar = findViewById(R.id.test_handler_progress_bar);

        //新建靜態(tài)內部類 Handler 對象
        mMainHandler = new Handler(getMainLooper());

        Button mClickBtn = findViewById(R.id.click_btn);
        mClickBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //開啟子線程，子線程處理UI工作
                CustomChildThread customThread = new CustomChildThread();
                customThread.start();
            }
        });
    }

    /**
     * 子線程，用于處理耗時工作
     */
    public class CustomChildThread extends Thread {

        @Override
        public void run() {
            //模擬耗時進度，將進度值傳給主線程用于更新 ProgressBar 進度。
            for (int i = 1; i <= 5; i++) {
                try {
                    //讓當前執(zhí)行的線程（即 CustomChildThread）睡眠 1s
                    Thread.sleep(1000);

                    //新創(chuàng)建一個 Runnable 用戶處理 UI 工作
                    MyRunnable runnable = new MyRunnable(HandlerPostFunctionActivity.this, i);
                    //調用Handler post 方法。
                    mMainHandler.post(runnable);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 將 Runnable 寫成靜態(tài)內部類，防止內存泄露
     */
    public static class MyRunnable implements Runnable {
        private int progressBarValue;
        private WeakReference<HandlerPostFunctionActivity> weakReference;

        MyRunnable(HandlerPostFunctionActivity activity, int value) {
            this.weakReference = new WeakReference<>(activity);
            this.progressBarValue = value;
        }

        @Override
        public void run() {
            HandlerPostFunctionActivity activity = weakReference.get();
            if (activity != null && !activity.isFinishing()) {
                activity.mProgressBar.setProgress(progressBarValue);
            }
        }
    }
}

2.2 Kotlin版本的具體代碼如下：

class TestHandlerPostRunnableActivity : AppCompatActivity() {
    private var mMainHandler: Handler? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_thread_add_handler)

        handlerAddThreadStartBtn.setOnClickListener(View.OnClickListener {
            //工作線程開始模擬下載任務
            val workThread: WorkThread = WorkThread(this)
            workThread.start()
        })

        //創(chuàng)建 Handler，關聯(lián)App的 主Looper 對象
        mMainHandler = Handler(Looper.getMainLooper())
    }

    class WorkThread(private var activity: TestHandlerPostRunnableActivity) : Thread() {
        private var handler: Handler? = activity.mMainHandler

        override fun run() {
            super.run()
            for (i in 0..6) {
                sleep(1000)
                //新建 Runnable 設置進度參數(shù)傳，然后通過 post(Runnable) 方法，讓其更新 progressBar 進度
                val runnable: MyRunnable = MyRunnable(activity, i)
                handler?.post(runnable)
            }
        }
    }

    /**
     * 處理 UI 工作。
     * 靜態(tài)內部類，防止內存泄露
     */
    class MyRunnable(activity: TestHandlerPostRunnableActivity, value: Int) : Runnable {
        private var weakReference = WeakReference(activity)
        private var progressValue = value

        override fun run() {
            val activity = weakReference.get()
            if (activity != null && !activity.isFinishing) {
                //獲取任務執(zhí)行進度參數(shù)，更新 progressBar 進度
                activity.handlerAddThreadProgressBar.progress = progressValue
            }
        }
    }
}

3. obtainMessage()方法

obtainMessage() 方法與 sendMessage() 方法很相似，通過 mHandler.obtainMessage().sendToTarget() 發(fā)送信息。該方法與 sendMessage() 的區(qū)別就是你不用額外去創(chuàng)建一個 Message 對象。

obtainMessage() 方法有三種，分別是：

//指定 what 用于區(qū)分，通過 Message.what 獲得
public final Message obtainMessage(int what);

//傳遞obj參數(shù)，通過 Message.obj 獲得
public final Message obtainMessage(int what, @Nullable Object obj)

//傳遞arg1 arg2參數(shù)，通過 Message.arg1 Message.arg2 獲得
public final Message obtainMessage(int what, int arg1, int arg2)

3.1 Java版本的具體代碼如下：

public class HandlerObtainMessageActivity extends AppCompatActivity {
    private TextView mDisplayTv;
    private Handler mHandler;
    private ProgressBar mProgressBar;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_add_thread);

        TextView titleTv = findViewById(R.id.title_tv);
        titleTv.setText("Handler + Thread");

        mDisplayTv = findViewById(R.id.display_tv);
        mProgressBar = findViewById(R.id.test_handler_progress_bar);

        //mHandler用于處理主線程消息隊列中的子線程消息
        mHandler = new Handler(Looper.getMainLooper()) {
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                switch (msg.what) {
                    case 1:
                        //更新 TextView UI
                        mDisplayTv.setText("Handler obtainMessage() Test!!");
                        break;
                    case 2:
                        //通過 msg.obj 獲取 ProgressBar 的進度，然后顯示進度值
                        int process = (int) msg.obj;
                        mProgressBar.setProgress(process);
                        break;
                    default:
                        break;
                }

            }
        };

        Button mClickBtn = findViewById(R.id.click_btn);
        mClickBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //開啟子線程，子線程處理UI工作
                CustomChildThread customThread = new CustomChildThread();
                customThread.start();
            }
        });
    }

    /**
     * 子線程，用于處理耗時工作
     */
    public class CustomChildThread extends Thread {

        @Override
        public void run() {
            //發(fā)送第一條消息，代表開始執(zhí)行異步任務
            mHandler.obtainMessage(1).sendToTarget();

            //模擬耗時進度，將進度值傳給主線程用于更新 ProgressBar 進度。
            for (int i = 1; i <= 5; i++) {
                try {
                    //讓當前執(zhí)行的線程（即 CustomChildThread）睡眠 1s
                    Thread.sleep(1000);

                    //將執(zhí)行進度參數(shù) i 傳遞給主線程 progressBar
                    mHandler.obtainMessage(2, i).sendToTarget();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }


        }
    }

}

3.2 Kotlin版本的具體代碼如下：

class TestHandlerObtainMessageActivity : AppCompatActivity() {
    companion object {
        const val PROGRESS_VALUE_KEY = "PROGRESS_VALUE"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_thread_add_handler)

        handlerAddThreadStartBtn.setOnClickListener(View.OnClickListener {
            //工作線程開始模擬下載任務
            val workThread: WorkThread = WorkThread(this)
            workThread.start()
        })
    }

    class WorkThread(activity: TestHandlerObtainMessageActivity) : Thread() {
        private var handler: MyHandler = MyHandler(activity)

        override fun run() {
            super.run()
            for (i in 0..6) {
                sleep(1000)
                //通過 Handler 將進度參數(shù)傳遞給 主線程，讓其更新 progressBar 進度
                val bundle = Bundle()
                bundle.putInt(PROGRESS_VALUE_KEY, i)
                handler.obtainMessage(1, bundle).sendToTarget()
            }
        }
    }

    /**
     * 靜態(tài)內部類，防止內存泄漏
     */
    class MyHandler(activity: TestHandlerObtainMessageActivity) : Handler() {
        private var weakReference = WeakReference(activity)

        override fun handleMessage(msg: Message) {
            super.handleMessage(msg)
            when (msg.what) {
                1 -> {
                    val activity = weakReference.get()
                    if (activity != null && !activity.isFinishing) {
                        //獲取任務執(zhí)行進度參數(shù)，然后通過 ProgressBar 顯示出來
                        val bundle: Bundle = msg.obj as Bundle
                        val progressValue: Int = bundle.get(PROGRESS_VALUE_KEY) as Int
                        activity.handlerAddThreadProgressBar.progress = progressValue
                    }
                }
            }
        }
    }
}

4. 總結：

在實際開發(fā)中，三種方法的使用都可行，具體用哪種方法，需結合你的實際情況及個人喜好。另外，在實際使用中往往將 Handler 寫成靜態(tài)內部類，這時需要注意防止內存泄露！（The handler class should be static or leaks might occur），具體代碼見上方！

4.1 在子線程中創(chuàng)建Handler

思考： 在上面代碼中， 我們都是在主線程中創(chuàng)建了 Handler 對象，那如果在子線程中創(chuàng)建一個 Handler 對象呢？會發(fā)生什么呢？
如下所示：我們在 CustomChildThread 線程中，新建一個 Handler 對象。

public class CustomChildThread extends Thread {
    @Override
    public void run() {
        Handler handler = new Handler(Activity.this);
        //會報錯：java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
    }
}

結果： 拋出異常: java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()。

原因： 因為在創(chuàng)建 Handler對象時要關聯(lián)所處線程的 Looper對象，而我們的子線程沒有 Looper，所以會拋出上述異常。

解決方法： 通過調用，Looper.prepare() 方法為子線程創(chuàng)建一個 Looper 對象，并且調用 Looper.loop() 方法開始消息循環(huán)。如下所示：

class CustomChildThread extends Thread {
    @Override
    public void run() {
        //為當前線程創(chuàng)建一個 Looper 對象
        Looper.prepare();
        
        //在子線程中創(chuàng)建一個 Handler 對象
        Handler handler = new Handler() {
            public void handleMessage(Message msg) {
                // 在這里處理傳入的消息
            }
        };
        //開始消息循環(huán)
        Looper.loop();
    }
}

以上就是詳解Android的Handler機制原理的詳細內容，更多關于Android Handler機制的資料請關注腳本之家其它相關文章！

相關文章

最新評論