Android Handler机制、原理与示例 基本示例创建与使用主线程 Handlerpublic class MainActivity extends AppCompatActivity {private Handler mHandler;private TextView mTextView;Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mTextView findViewById(R.id.text_view); // 在主线程创建 Handler mHandler new Handler(Looper.getMainLooper()) { Override public void handleMessage(NonNull Message msg) { switch (msg.what) { case 1: mTextView.setText(收到消息 msg.obj); break; } } }; // 启动子线程发送消息 new Thread(new Runnable() { Override public void run() { try { Thread.sleep(2000); Message msg Message.obtain(); msg.what 1; msg.obj 来自子线程的消息; mHandler.sendMessage(msg); // 或使用便捷方式 mHandler.post(() - { mTextView.setText(通过 post 更新 UI); }); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); }}创建与使用子线程 Handlerpublic class MainActivity extends AppCompatActivity {private HandlerThread handlerThread;private Handler handler;Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);// 创建 HandlerThread handlerThread new HandlerThread(MyHandlerThread); handlerThread.start(); // 创建 Handler关联到 HandlerThread 的 Looper handler new Handler(handlerThread.getLooper()) { Override public void handleMessage(Message msg) { // 在子线程执行 Log.d(Handler, 处理消息: msg.what); } }; // 发送任务 handler.post(new Runnable() { Override public void run() { // 在 HandlerThread 中执行 Log.d(Handler, 执行任务); } });}Overrideprotected void onDestroy() {super.onDestroy();// 退出消息循环if (handlerThread ! null) {handlerThread.quitSafely();}}}// 创建子线程new Thread(new Runnable() {Overridepublic void run() {// 1. 初始化 LooperLooper.prepare();// 2. 创建 Handler Handler handler new Handler(Looper.myLooper()) { Override public void handleMessage(Message msg) { // 处理消息 Log.d(Handler, 收到消息: msg.what); } }; // 3. 启动消息循环 Looper.loop(); }}).start();定时任务示例// 延迟执行mHandler.postDelayed(() - {Log.d(“Handler”, “3秒后执行”);}, 3000);// 循环执行private Runnable mUpdateTask new Runnable() {Overridepublic void run() {updateUI();// 每1秒执行一次mHandler.postDelayed(this, 1000);}};// 开始循环mHandler.post(mUpdateTask);// 停止循环重要防止内存泄漏Overrideprotected void onDestroy() {super.onDestroy();mHandler.removeCallbacks(mUpdateTask);}说明.获取looper的方式Looper.getMainLooper()始终返回主线程的 LooperLooper.myLooper()获取当前线程的 Looper可能返回 nullhandler.getLooper()handlerThread.getLooper().一个handler对应一个Looper一个Looper可以对应多个handler 核心机制Handler 四件套┌─────────────────────────────────────────┐│ MessageQueue消息队列 ││ ┌─────────────┬─────────────┐ ││ │ Message1 │ Message2 │ … ││ └─────────────┴─────────────┘ │└─────────────┬──────────────────────────┘│┌─────────────▼──────────────────────────┐│ Looper消息循环器 ││ • 从 MessageQueue 取出消息 ││ • 分发给对应的 Handler │└─────────────┬──────────────────────────┘│┌─────────────▼──────────────────────────┐│ Handler消息处理器 ││ • 发送消息到 MessageQueue ││ • 处理 Looper 分发的消息 │└─────────────┬──────────────────────────┘│┌─────────────▼──────────────────────────┐│ Message消息 ││ • what: 消息标识 ││ • arg1/arg2: 整型参数 ││ • obj: 对象参数 ││ • target: 目标 Handler │└────────────────────────────────────────┘ 工作原理消息循环流程// Looper.loop() 简化逻辑public static void loop() {final Looper me myLooper();final MessageQueue queue me.mQueue;for (;;) { // 1. 从队列取消息可能阻塞 Message msg queue.next(); if (msg null) return; // 2. 分发给目标 Handler msg.target.dispatchMessage(msg); // 3. 回收消息到池中 msg.recycleUnchecked(); }}消息发送与处理// Handler.sendMessage() 流程public boolean sendMessage(Message msg) {return sendMessageDelayed(msg, 0);}public boolean sendMessageDelayed(Message msg, long delayMillis) {// 设置消息的目标 Handlermsg.target this;// 计算执行时间 if (delayMillis 0) delayMillis 0; long when SystemClock.uptimeMillis() delayMillis; // 入队 return queue.enqueueMessage(msg, when);}// 消息分发public void dispatchMessage(Message msg) {if (msg.callback ! null) {// 处理 RunnablehandleCallback(msg);} else {if (mCallback ! null) {if (mCallback.handleMessage(msg)) return;}// 调用 handleMessage()handleMessage(msg);}}⚙️ 关键技术点线程绑定// 主线程 Looper 初始化ActivityThread.main()public static void main(String[] args) {Looper.prepareMainLooper(); // 创建主线程 LooperActivityThread thread new ActivityThread();thread.attach(false);if (sMainThreadHandler null) { sMainThreadHandler thread.getHandler(); } Looper.loop(); // 开启消息循环 throw new RuntimeException(Main thread loop unexpectedly exited);}// 子线程使用 Handlernew Thread(() - {// 1. 准备 LooperLooper.prepare();// 2. 创建 Handler会自动绑定当前线程的 Looper Handler handler new Handler() { Override public void handleMessage(Message msg) { // 处理消息 } }; // 3. 开启循环 Looper.loop();}).start();消息池优化// 消息池避免频繁创建对象Message msg Message.obtain(); // 推荐从池中获取// vsMessage msg new Message(); // 不推荐每次创建新对象// 使用后系统自动回收msg.recycleUnchecked();同步屏障Sync Barrier// 紧急消息处理public int postSyncBarrier() {return mQueue.postSyncBarrier(SystemClock.uptimeMillis());}// 异步消息优先级更高msg.setAsynchronous(true);mHandler.sendMessage(msg); 注意事项内存泄漏处理// 错误示例匿名内部类持有 Activity 引用private Handler mHandler new Handler() {Overridepublic void handleMessage(Message msg) {// 持有外部类引用}};// 正确示例1静态内部类 弱引用private static class SafeHandler extends Handler {private final WeakReference mActivity;public SafeHandler(Activity activity) { mActivity new WeakReference(activity); } Override public void handleMessage(Message msg) { Activity activity mActivity.get(); if (activity ! null !activity.isFinishing()) { // 安全操作 } }}// 正确示例2在 onDestroy 中清理Overrideprotected void onDestroy() {super.onDestroy();mHandler.removeCallbacksAndMessages(null);}跨线程通信// 子线程 → 主线程new Thread(() - {// 耗时操作String result doBackgroundWork();// 方式1sendMessage Message msg Message.obtain(mainHandler); msg.obj result; mainHandler.sendMessage(msg); // 方式2post更简洁 mainHandler.post(() - updateUI(result)); // 方式3runOnUiThreadActivity 中 runOnUiThread(() - updateUI(result));}).start();HandlerThread 使用// 创建自带 Looper 的工作线程HandlerThread handlerThread new HandlerThread(“WorkerThread”);handlerThread.start();// 获取该线程的 HandlerHandler workerHandler new Handler(handlerThread.getLooper());// 在工作线程执行任务workerHandler.post(() - {// 在 WorkerThread 中执行doHeavyWork();// 完成后通知主线程 mainHandler.post(() - updateUI());});// 结束时清理handlerThread.quitSafely(); 性能优化建议消息复用使用 Message.obtain() 而非 new Message()及时清理在合适的生命周期移除回调避免过度使用简单的定时任务可用 postDelayed复杂调度考虑 RxJava 或 Coroutine线程管理使用 HandlerThread 管理后台线程的 Looper同步屏障谨慎用只在必要时使用异步消息这种机制使得 Android 能够实现高效、安全的线程间通信是 Android 异步编程的基石。