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

詳解Android的Handler機制原理

 更新時間：2023年10月31日 11:08:19   作者：淘淘養(yǎng)樂多  
Android的Handler機制是一種用于處理和調(diào)度線程之間消息傳遞的機制,通常用于在后臺線程中執(zhí)行任務,并將結(jié)果返回到主線程中更新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)內(nèi)部類，防止內(nè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)內(nè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);
                    //調(diào)用Handler post 方法。
                    mMainHandler.post(runnable);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 將 Runnable 寫成靜態(tài)內(nèi)部類，防止內(nè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)內(nèi)部類，防止內(nè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)內(nèi)部類，防止內(nè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. 總結(jié)：

在實際開發(fā)中，三種方法的使用都可行，具體用哪種方法，需結(jié)合你的實際情況及個人喜好。另外，在實際使用中往往將 Handler 寫成靜態(tài)內(nèi)部類，這時需要注意防止內(nèi)存泄露?。═he 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()
    }
}

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

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

解決方法： 通過調(diào)用，Looper.prepare() 方法為子線程創(chuàng)建一個 Looper 對象，并且調(diào)用 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機制原理的詳細內(nèi)容，更多關于Android Handler機制的資料請關注腳本之家其它相關文章！

相關文章

最新評論