0
点赞
收藏
分享

微信扫一扫

Android handler详解

思考的鸿毛 01-27 12:00 阅读 12
ide消息队列后台线程Android移动开发yyds干货盘点
加载失败

在 Android 开发中，Handler 是一个用于在不同线程之间传递消息和执行任务的重要机制。它通常用于在后台线程中处理耗时操作，并将结果传递回主线程（UI 线程）以更新 UI。以下是 Handler 的详细解析，包括其工作原理、使用方法、关键组件和示例代码。

1. 基本概念

Handler 是一个消息处理机制，允许你将消息（Message）或任务（Runnable）发送到与特定线程关联的消息队列（MessageQueue），并在该线程中处理这些消息或任务。

2. 工作原理

2.1. 线程和消息队列
  • 线程：每个线程可以有一个与之关联的消息队列。
  • 消息队列：MessageQueue 是一个先进先出（FIFO）的数据结构，用于存储消息和任务。
2.2. Looper
  • Looper：Looper 是一个无限循环，用于从消息队列中取出消息并分发给相应的 Handler 处理。
  • 主线程的 Looper：主线程（UI 线程）默认有一个 Looper，因此可以直接使用 Handler 处理消息。
  • 其他线程的 Looper：其他线程需要手动创建和启动 Looper 才能使用 Handler。
2.3. 消息处理流程
  1. 创建 Handler：在特定线程中创建 Handler 实例。
  2. 发送消息：通过 Handler 发送消息或任务到消息队列。
  3. Looper 分发消息：Looper 从消息队列中取出消息，并分发给相应的 Handler。
  4. 处理消息：Handler 处理消息或任务。

3. 关键组件

3.1. Handler
  • 创建 Handler：可以在任何线程中创建 Handler，但通常在主线程中创建以更新 UI。
  • 发送消息：使用 sendMessage、post 等方法发送消息或任务。

Handler handler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
        // 处理消息
    }
};

3.2. Message
  • 创建 Message：使用 Message.obtain() 或 Handler.obtainMessage() 创建消息。
  • 设置消息内容：设置消息的 what、arg1、arg2、obj 等字段。

Message msg = handler.obtainMessage();
msg.what = 1;
msg.obj = "Hello, World!";
handler.sendMessage(msg);

3.3. MessageQueue
  • 消息队列：MessageQueue 存储消息和任务，按照时间戳排序。
  • 消息分发：Looper 从消息队列中取出消息并分发给相应的 Handler。
3.4. Looper
  • 创建 Looper：使用 Looper.prepare() 创建 Looper。
  • 启动 Looper：使用 Looper.loop() 启动 Looper。

class MyThread extends Thread {
    public Handler handler;

    @Override
    public void run() {
        Looper.prepare();
        handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                // 处理消息
            }
        };
        Looper.loop();
    }
}

4. 使用方法

4.1. 在主线程中使用 Handler
  • 更新 UI：在主线程中创建 Handler，用于更新 UI。

public class MainActivity extends AppCompatActivity {
    private Handler mainHandler;

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

        mainHandler = new Handler(Looper.getMainLooper());

        new Thread(new Runnable() {
            @Override
            public void run() {
                // 耗时操作
                String result = "Data from background thread";
                mainHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        // 更新 UI
                        TextView textView = findViewById(R.id.textView);
                        textView.setText(result);
                    }
                });
            }
        }).start();
    }
}

4.2. 在后台线程中使用 Handler
  • 处理后台任务：在后台线程中创建 Handler，用于处理后台任务。

public class BackgroundThread extends Thread {
    public Handler handler;

    @Override
    public void run() {
        Looper.prepare();
        handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                // 处理消息
                switch (msg.what) {
                    case 1:
                        // 处理任务
                        break;
                }
            }
        };
        Looper.loop();
    }
}

public class MainActivity extends AppCompatActivity {
    private BackgroundThread backgroundThread;

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

        backgroundThread = new BackgroundThread();
        backgroundThread.start();

        // 发送消息到后台线程
        backgroundThread.handler.sendEmptyMessage(1);
    }
}

4.3. 使用 HandlerThread
  • 简化后台线程的创建：HandlerThread 是一个带有 Looper 的线程，简化了后台线程的创建和使用。

public class MainActivity extends AppCompatActivity {
    private HandlerThread handlerThread;
    private Handler backgroundHandler;

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

        handlerThread = new HandlerThread("BackgroundThread");
        handlerThread.start();
        backgroundHandler = new Handler(handlerThread.getLooper());

        // 发送任务到后台线程
        backgroundHandler.post(new Runnable() {
            @Override
            public void run() {
                // 耗时操作
                String result = "Data from background thread";
                mainHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        // 更新 UI
                        TextView textView = findViewById(R.id.textView);
                        textView.setText(result);
                    }
                });
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        handlerThread.quitSafely();
    }
}

5. 关键方法

5.1. 发送消息
  • sendMessage：发送消息到消息队列。
  • post：发送 Runnable 到消息队列，并在指定延迟后执行。
  • postDelayed：发送 Runnable 到消息队列，并在指定延迟后执行。
  • postAtTime：发送 Runnable 到消息队列，并在指定时间执行。
  • removeMessages：移除特定 what 的消息。
  • removeCallbacks：移除特定的 Runnable。

handler.sendMessage(msg);
handler.post(new Runnable() {
    @Override
    public void run() {
        // 执行任务
    }
});
handler.postDelayed(new Runnable() {
    @Override
    public void run() {
        // 执行任务
    }
}, 1000); // 延迟1秒执行

5.2. 处理消息
  • handleMessage：重写 Handler 的 handleMessage 方法，处理消息。

Handler handler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case 1:
                // 处理消息
                break;
        }
    }
};

6. 注意事项

6.1. 线程安全
  • 线程安全：Handler 和 MessageQueue 是线程安全的，但处理消息的逻辑需要确保线程安全。
6.2. 避免内存泄漏
  • 内存泄漏：确保 Handler 不持有外部类的强引用，避免内存泄漏。可以使用静态内部类或 WeakReference。

public class MainActivity extends AppCompatActivity {
    private static class MyHandler extends Handler {
        private WeakReference<MainActivity> activityReference;

        MyHandler(MainActivity activity) {
            activityReference = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            MainActivity activity = activityReference.get();
            if (activity != null) {
                // 处理消息
            }
        }
    }

    private MyHandler handler;

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

        handler = new MyHandler(this);
    }
}

6.3. 退出 Looper
  • 退出 Looper：在不需要时退出 Looper，避免线程泄漏。

@Override
protected void onDestroy() {
    super.onDestroy();
    handlerThread.quitSafely();
}

7. 示例代码

以下是一些完整的示例代码，展示如何在不同场景中使用 Handler。

7.1. 主线程中使用 Handler 更新 UI

public class MainActivity extends AppCompatActivity {
    private Handler mainHandler;
    private TextView textView;

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

        textView = findViewById(R.id.textView);
        mainHandler = new Handler(Looper.getMainLooper());

        new Thread(new Runnable() {
            @Override
            public void run() {
                // 耗时操作
                String result = "Data from background thread";
                mainHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        // 更新 UI
                        textView.setText(result);
                    }
                });
            }
        }).start();
    }
}

7.2. 后台线程中使用 Handler 处理任务

public class BackgroundThread extends Thread {
    public Handler handler;

    @Override
    public void run() {
        Looper.prepare();
        handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                // 处理消息
                switch (msg.what) {
                    case 1:
                        // 处理任务
                        break;
                }
            }
        };
        Looper.loop();
    }
}

public class MainActivity extends AppCompatActivity {
    private BackgroundThread backgroundThread;
    private Handler mainHandler;

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

        mainHandler = new Handler(Looper.getMainLooper());
        backgroundThread = new BackgroundThread();
        backgroundThread.start();

        // 发送消息到后台线程
        backgroundThread.handler.sendEmptyMessage(1);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        backgroundThread.quitSafely();
    }
}

7.3. 使用 HandlerThread 简化后台线程

public class MainActivity extends AppCompatActivity {
    private HandlerThread handlerThread;
    private Handler backgroundHandler;
    private Handler mainHandler;
    private TextView textView;

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

        textView = findViewById(R.id.textView);
        mainHandler = new Handler(Looper.getMainLooper());

        handlerThread = new HandlerThread("BackgroundThread");
        handlerThread.start();
        backgroundHandler = new Handler(handlerThread.getLooper());

        // 发送任务到后台线程
        backgroundHandler.post(new Runnable() {
            @Override
            public void run() {
                // 耗时操作
                String result = "Data from background thread";
                mainHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        // 更新 UI
                        textView.setText(result);
                    }
                });
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        handlerThread.quitSafely();
    }
}

8. 总结

  • Handler：用于在不同线程之间传递消息和执行任务。
  • 工作原理：通过 Looper 从消息队列中取出消息并分发给相应的 Handler 处理。
  • 关键组件：Handler、Message、MessageQueue 和 Looper。
  • 使用方法：在主线程或后台线程中创建 Handler，发送消息或任务，并处理消息。
  • 注意事项：确保线程安全、避免内存泄漏、正确退出 Looper。

通过理解 Handler 的工作原理和使用方法，可以有效地在 Android 应用中进行线程间通信和任务调度，提高应用的性能和稳定性。

举报

相关推荐

Android Handler消息机制详解

日记本

Android的Handler机制原理详解

主线程androidHandlerAndroid移动开发yyds干货盘点

Android Handler机制——Handler

android

handler详解

android主线程xmlPython后端开发

Android Handler

UIide消息队列JavaScript前端开发

Android Handler 解析

androidjava消息队列异步消息主线程JavaScript前端开发

Android Handler介绍

Handlerandroid主线程ide编程语言

android Handler 空闲

发送消息Android消息队列移动开发

【Android】Handler 机制 ( Handler | Message | Looper | MessageQueue )

HandlerLooperMessageMessageQueueAndroid

Android Handler 同步屏障

android异步消息主线程Linux系统/运维
0 条评论
加载失败