【Android】Handle（三）重要的知识点问答

我又来搬代码了

已于 2023-05-30 13:28:38 修改

阅读量1k

点赞数

分类专栏： Android学习笔记 Framework学习笔记文章标签： android java 开发语言

于 2023-05-30 13:25:22 首次发布

本文链接：https://blog.csdn.net/qq_43358469/article/details/130944797

版权

Android学习笔记同时被 2 个专栏收录

89 篇文章 7 订阅

订阅专栏

Framework学习笔记

15 篇文章 3 订阅

订阅专栏

一个线程有几个 Handler?

一个线程可以有多个Handler，并且每一个Handler都可以处理消息队列中的消息。每个Handler在创建时会与当前线程的消息队列相关联，因此可以通过Handler向该线程的消息队列发送消息。

需要注意的是，不同的Handler可能会被关联到相同的Looper（消息循环器）上，也可能不同的Handler使用各自独立的Looper来实现消息处理。例如，一个Activity可能会创建多个Handler对象，其中一些Handler会在主线程上执行，而另一些Handler则会在新建的子线程上执行，它们分别使用了不同的Looper来处理消息队列中的消息。

因此，可以说一个线程可以拥有多个Handler，这取决于应用程序设计的具体情况和需要。但是，由于在Android中每个线程都只有一个消息队列，因此多个Handler之间处理消息时可能会存在竞争和同步问题，需要开发者进行合理的规划和处理，以避免出现不必要的问题。

一个线程有几个 Looper?如何保证?

一个线程只能拥有一个Looper，这也是Android消息机制的基本原则之一。每个Looper都对应着一个消息队列，当线程调用Looper.loop()方法时，它就会开始监听该消息队列，处理其中的消息。

在Android中，主线程默认会创建一个Looper对象，并将其关联到主线程上。因此，在主线程中可以直接使用Handler，而不需要进行额外的操作。

如果要在新线程中使用Handler，需要先调用Looper.prepare()方法创建一个Looper对象，并将其关联到当前线程上，然后再通过Looper.loop()方法来启动消息循环器。

需要注意的是，Looper.prepare()方法和Looper.loop()方法必须成对出现，否则会抛出异常。通常建议在Handler所在线程的run()方法中进行Looper.prepare()和Looper.loop()的调用，以保证消息机制正常工作，并确保Looper只会被创建一次。

下面是一个简单的示例代码，展示了如何在新线程中使用Handler，并正确地创建和管理Looper对象：

public class MyThread extends Thread {
    private Handler mHandler;

    @Override
    public void run() {
        Looper.prepare(); // 创建Looper对象
        mHandler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                // 处理消息
                // ...
            }
        };
        Looper.loop(); // 开始消息循环器
    }

    public Handler getHandler() {
        return mHandler;
    }
}

在上面的代码中，我们创建了一个新线程MyThread，并在其run()方法中创建了一个Looper对象，并将它关联到该线程上。然后，我们通过Handler来处理消息队列中的消息，并提供了一个getHandler()方法，以便外界可以获取该线程的Handler对象。必要时，可以通过调用Looper.quit()方法来停止消息循环器并释放相关资源，避免内存泄露。

需要注意的是，由于Looper和Handler对象的关系是一对多的，因此在保障线程中只有一个Looper的前提下，可以存在多个Handler。而在多线程并发情况下，为保障数据安全，可以采取同步机制来控制消息队列的访问，比如使用synchronized关键字或Lock对象来加锁、解锁。

Handler内存泄漏原因?为什么其他的内部类没有说过有这个问题?

Handler内存泄漏的原因主要是由于Handler对象被长时间持有，导致它所在的Activity或Fragment无法及时释放，从而引起内存泄漏。具体来说，当一个Activity或Fragment包含一个Handler对象时，如果在消息队列中存在未被处理的消息，那么这个Activity或Fragment实例将无法正常销毁，并且会一直被持有，从而造成内存泄漏。

与其他内部类相比，Handler对象与Activity或Fragment之间通常存在着相互引用的关系，因此容易出现内存泄漏问题。例如，在Activity中使用Handler对象进行定时任务的管理时，很容易出现内存泄漏问题，因为该Handler对象可能会一直持有Activity实例，导致Activity无法被正常回收。

为了避免Handler内存泄漏问题，可以采取以下措施：

尽量避免使用匿名内部类来创建Handler对象，避免对外部Activity或Fragment的隐式引用。
将Handler对象定义成静态内部类，并将其与弱引用（WeakReference）关联，以保证Activity或Fragment实例可以被正确释放。
在Activity或Fragment的onDestroy()方法中，手动调用Handler对象的removeCallbacksAndMessages()方法，清除消息队列中未被处理的消息。这样可以避免Handler对象持有Activity或Fragment实例的时间过长。
需要注意的是，即使是正确使用Handler对象，也不能完全杜绝内存泄漏问题，因为Android系统本身就具有一定的内存泄漏风险。因此，在编写Android应用时，需要特别关注内存管理问题，并尽可能地减少内存泄漏的风险。

为何主线程可以newHandler?如果想要在子线程中new Handler 要做些什么准备?

在Android中，主线程可以直接创建Handler对象，是因为Android系统默认会在主线程中创建Looper对象，并将其关联到当前线程。而Looper对象是用于消息循环的，而Handler对象则是用于向消息队列中发送和处理消息的。因此，在主线程中可以直接使用Handler对象，不需要进行额外的准备工作。

如果想要在子线程中创建Handler对象，需要先调用Looper.prepare()方法创建一个Looper对象，并将其关联到当前线程上，然后再通过Looper.loop()方法来启动消息循环器。同时，需要注意在Handler对象所在线程的run()方法中进行Looper.prepare()和Looper.loop()的调用，以保证消息机制正常工作，并确保Looper只会被创建一次。

除此之外，为避免Handler内存泄漏问题，还需要采取一些特殊的准备工作：
将Handler对象定义成静态内部类，并将其与弱引用（WeakReference）关联，以保证Activity或Fragment实例可以被正确释放。
在Handler对象所在的线程中，手动调用Looper.quit()方法来停止消息循环器并释放相关资源，避免内存泄露。
在Activity或Fragment的onDestroy()方法中，手动调用Handler对象的removeCallbacksAndMessages()方法，清除消息队列中未被处理的消息。这样可以避免Handler对象持有Activity或Fragment实例的时间过长。
总之，要在子线程中创建和使用Handler对象，需要进行额外的准备工作，以确保消息机制正常运作，并避免内存泄漏问题。同时，在编写Android应用时，也要特别注意内存管理问题，并尽可能地减少内存泄漏的风险。

子线程中维护的Looper，消息队列无消息的时候的处理方案是什么? 有什么用?

当子线程中维护的Looper中的消息队列无消息时，该Looper会进入睡眠状态，等待下一条消息的到来。此时，Looper会调用MessageQueue的next方法，进入阻塞状态，直到有消息到来或者当前线程被中断或销毁。

这种机制的主要作用是避免了CPU空转，减少了不必要的资源浪费。如果没有消息到来时，线程处于等待状态，CPU不再执行相关代码，从而降低了CPU的使用率，减少了电量消耗。

另外，子线程中维护的Looper可以用于实现异步任务处理和UI更新的功能。通过向子线程中的Handler对象中发送消息，可以让子线程执行一些耗时的操作，并将处理结果返回给主线程，以便进行UI更新等操作。同时，通过维护一个独立的消息队列，可以保证任务的顺序执行，避免了多线程竞争的问题。

总之，子线程中维护的Looper和消息队列是Android消息机制的核心组成部分，可以用于实现异步任务处理、UI更新、事件分发等功能，同时还可以优化系统资源的使用效率，提高应用程序的响应速度和稳定性。

既然可以存在多个Handler往MessageQueue中添加数据(发消息时各个Handler 可能处于不同线程）,那它内部是如何确保线程安全的?

在Android中，MessageQueue的内部实现采用了单线程模型，即它的所有操作（添加消息、取出消息等）都是在同一个线程（Looper所在线程）中执行的，因此不存在多线程竞争的情况。

在实际应用中，如果存在多个Handler往同一个MessageQueue中添加数据，可能会涉及到线程同步的问题。这时可以通过以下两种方式来确保线程安全：
使用同步关键字或ReentrantLock等锁机制：在多个Handler中，使用同一把锁来保证多线程操作时的同步性，避免出现并发问题。
使用线程安全的队列类：例如LinkedBlockingQueue、ConcurrentLinkedQueue等，这些队列类内部已经实现了线程安全机制，可以直接在多线程环境中使用。
需要注意的是，在多个Handler并发地向同一个MessageQueue中添加数据时，还需要考虑消息顺序的问题。可以通过给每个消息打上唯一标识符或者设置优先级等方式来保证消息的顺序性，避免出现消息乱序的情况。

我们使用Message时应该如何创建它?

在Android中，使用Message来传递消息是一种比较常见的方式。使用Message时，可以通过以下两种方式来创建它：

1.使用Message.obtain()方法：这是一种比较常用的方式，可以复用已经存在的Message对象，避免了频繁地创建和销毁Message对象，提高了系统的性能和效率。使用该方法时，需要先调用Message.obtain()方法获取Message对象，然后再设置消息的what、arg1、arg2等属性。

示例代码如下：
```
// 在Handler中创建Message
Message msg = Message.obtain();
msg.what = MSG_HELLO;
msg.arg1 = 100;
msg.arg2 = 200;
msg.obj = "Hello world!";
handler.sendMessage(msg);
```
2.直接使用Message的构造函数：这是一种比较直接的方式，可以直接使用Message的构造函数来创建新的Message对象。但是需要注意的是，使用该方式会频繁地创建和销毁Message对象，可能会对系统性能产生不利影响。

示例代码如下：
```
// 在Handler中创建Message
Message msg = new Message();
msg.what = MSG_HELLO;
msg.arg1 = 100;
msg.arg2 = 200;
msg.obj = "Hello world!";
handler.sendMessage(msg);
```
需要注意的是，在创建Message对象时，需要根据具体的业务需求来设置消息的what、arg1、arg2等属性，并且可以使用obj参数来传递任意类型的对象。在通过Handler将消息发送到消息队列之前，还可以通过target参数来设置消息的接收者，以便消息可以直接发送到对应的Handler中进行处理。

Looper死循环为什么不会导致应用卡死

在Android中，Looper是通过一个死循环来不断地处理MessageQueue中的消息。这种设计并不会导致应用卡死，主要有以下几个原因：
处理消息的时间非常短暂：Looper在处理一个消息时，通常只需要执行一些简单的逻辑，比如调用Handler的handleMessage()方法。由于处理时间非常短暂，因此不会对应用的主线程造成明显的阻塞。
睡眠时间可以有效降低CPU使用率：当MessageQueue中没有消息时，Looper会进入睡眠状态，等待下一条消息的到来。这种机制可以避免CPU空转，降低CPU的使用率，以便减少电量消耗。
Android采用多线程架构：在Android中，应用被分为多个进程和多个线程，这些进程和线程都是相互独立的。即使一个线程出现了问题，也不会对整个应用造成影响。因此，在Looper中发生异常或死循环时，只会影响当前线程，不会对其他线程和应用造成影响。

需要注意的是，虽然Looper的死循环不会导致应用卡死，但是如果应用中存在长时间的计算或者I/O操作，仍然会对应用的UI响应和用户体验造成影响。为了避免这种情况，应该尽可能将这些操作放到子线程中执行，并通过Handler等方式与主线程进行通信，以便保证应用的流畅和稳定。