精选Android高级面试题 : 深探Handler，多线程，Bitmap

作者：Focusing

1、谈谈消息机制Handler作用 ？有哪些要素 ？流程是怎样的 ？

参考回答：负责跨线程通信，这是因为在主线程不能做耗时操作，而子线程不能更新UI，所以当子线程中进行耗时操作后需要更新UI时，通过Handler将有关UI的操作切换到主线程中执行。

具体分为四大要素：

• Message（消息）：需要被传递的消息，消息分为硬件产生的消息（如按钮、触摸）和软件生成的消息。

• MessageQueue（消息队列）：负责消息的存储与管理，负责管理由 Handler发送过来的Message。读取会自动删除消息，单链表维护，插入和删除上有优势。在其next()方法中会无限循环，不断判断是否有消息，有就返回这条消息并移除。

• Handler（消息处理器）：负责Message的发送及处理。主要向消息池发送各种消息事件（Handler.sendMessage()）和处理相应消息事件（Handler.handleMessage()），按照先进先出执行，内部使用的是单链表的结构。

• Looper（消息池）：负责关联线程以及消息的分发，在该线程下从 MessageQueue获取 Message，分发给Handler，Looper创建的时候会创建一个 MessageQueue，调用loop()方法的时候消息循环开始，其中会不断调用messageQueue的next()方法，当有消息就处理，否则阻塞在messageQueue的next()方法中。当Looper的quit()被调用的时候会调用messageQueue的quit()，此时next()会返回null，然后loop()方法也就跟着退出。

具体流程如下：

在主线程创建的时候会创建一个Looper，同时也会在在Looper内部创建一个消息队列。而在创键Handler的时候取出当前线程的Looper，并通过该Looper对象获得消息队列，然后Handler在子线程中通过MessageQueue.enqueueMessage在消息队列中添加一条Message。

通过Looper.loop() 开启消息循环不断轮询调用 MessageQueue.next()，取得对应的Message并且通过Handler.dispatchMessage传递给Handler，最终调用Handler.handlerMessage处理消息。

2、一个线程能否创建多个Handler，Handler跟Looper之间的对应关系 ？

参考回答：一个Thread只能有一个Looper，一个MessageQueen，可以有多个Handler。

以一个线程为基准，他们的数量级关系是：Thread(1) : Looper(1) : MessageQueue(1) : Handler(N)。

3、软引用跟弱引用的区别

参考回答：

• 软引用（SoftReference）：如果一个对象只具有软引用，则内存空间充足时，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以一直被程序使用。

• 弱引用（WeakReference）：如果一个对象只具有弱引用，那么在垃圾回收器线程扫描的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。

• 两者之间根本区别在于：只具有弱引用的对象拥有更短暂的生命周期，可能随时被回收。而只具有软引用的对象只有当内存不够的时候才被回收，在内存足够的时候，通常不被回收。

推荐文章：Java中的四种引用类型：强引用、软引用、弱引用和虚引用（https://segmentfault.com/a/1190000015282652）

4、Handler 引起的内存泄露原因以及最佳解决方案

泄露原因：Handler 允许我们发送延时消息，如果在延时期间用户关闭了 Activity，那么该 Activity 会泄露。这个泄露是因为 Message 会持有 Handler，而又因为 Java 的特性，内部类会持有外部类，使得 Activity 会被 Handler 持有，这样最终就导致 Activity 泄露。

解决方案：将 Handler 定义成静态的内部类，在内部持有Activity的弱引用，并在Acitivity的onDestroy()中调用handler.removeCallbacksAndMessages(null)及时移除所有消息。

5、为什么系统不建议在子线程访问UI？

参考回答：Android的UI控件不是线程安全的，如果在多线程中并发访问可能会导致UI控件处于不可预期的状态。

这时你可能会问为何系统不对UI控件的访问加上锁机制呢？因为：

• 加锁机制会让UI访问逻辑变的复杂

• 加锁机制会降低UI的访问效率,因为加锁会阻塞某些线程的执行

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

参考回答：

• 主线程的主要方法就是消息循环，一旦退出消息循环，那么你的应用也就退出了，Looer.loop（）方法可能会引起主线程的阻塞，但只要它的消息循环没有被阻塞，能一直处理事件就不会产生ANR异常。

• 造成ANR的不是主线程阻塞，而是主线程的Looper消息处理过程发生了任务阻塞，无法响应手势操作，不能及时刷新UI。

• 阻塞与程序无响应没有必然关系，虽然主线程在没有消息可处理的时候是阻塞的，但是只要保证有消息的时候能够立刻处理，程序是不会无响应的。

7、使用Handler的postDealy后消息队列会有什么变化？

参考回答：如果队列中只有这个消息，那么消息不会被发送，而是计算到时唤醒的时间，先将Looper阻塞，到时间就唤醒它。但如果此时要加入新消息，该消息队列的对头跟delay时间相比更长，则插入到头部，按照触发时间进行排序，队头的时间最小、队尾的时间最大。

8、可以在子线程直接new一个Handler吗？怎么做？

参考回答：不可以，因为在主线程中，Activity内部包含一个Looper对象，它会自动管理Looper，处理子线程中发送过来的消息。而对于子线程而言，没有任何对象帮助我们维护Looper对象，所以需要我们自己手动维护。所以要在子线程开启Handler要先创建Looper，并开启Looper循环

推荐文章：Android异步消息处理机制完全解析，带你从源码的角度彻底理解（https://blog.csdn.net/guolin_blog/article/details/9991569）

9、Message可以如何创建？哪种效果更好，为什么？

参考回答：可以通过三种方法创建：

• 直接生成实例Message m = new Message

• 通过Message m = Message.obtain

• 通过Message m = mHandler.obtainMessage()

1、线程池的好处？四种线程池的使用场景，线程池的几个参数的理解？

使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或则“过度切换”的问题，归纳总结就是：

• 重用存在的线程，减少对象创建、消亡的开销，性能佳。

• 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。

• 提供定时执行、定期执行、单线程、并发数控制等功能。

Android中的线程池都是直接或间接通过配置ThreadPoolExecutor来实现不同特性的线程池.Android中最常见的类具有不同特性的线程池分别为：

• newCachedThreadPool：只有非核心线程，最大线程数非常大，所有线程都活动时会为新任务创建新线程,否则会利用空闲线程 ( 60s空闲时间,过了就会被回收,所以线程池中有0个线程的可能 )来处理任务.
  

        优点：任何任务都会被立即执行(任务队列SynchronousQuue相当于一个空集合);比较适合执行大量的耗时较少的任务.

• newFixedThreadPool：只有核心线程，并且数量固定的，所有线程都活动时，因为队列没有限制大小，新任务会等待执行，当线程池空闲时不会释放工作线程，还会占用一定的系统资源。
  

        优点：更快的响应外界请求

• newScheduledThreadPool：核心线程数固定,非核心线程（闲着没活干会被立即回收数）没有限制.
  

        优点：执行定时任务以及有固定周期的重复任务

• newSingleThreadExecutor：只有一个核心线程,确保所有的任务都在同一线程中按序完成

        优点：不需要处理线程同步的问题

推荐文章：java线程池解析和四种线程池的使用（https://blog.csdn.net/ztchun/article/details/57413255）

2、Android中还了解哪些方便线程切换的类？

参考回答：

• AsyncTask：底层封装了线程池和Handler，便于执行后台任务以及在子线程中进行UI操作。

• HandlerThread：一种具有消息循环的线程，其内部可使用Handler。

• IntentService：是一种异步、会自动停止的服务，内部采用HandlerThread。

3、讲讲AsyncTask的原理：

AsyncTask中有两个线程池（SerialExecutor和THREAD_POOL_EXECUTOR）和一个Handler（InternalHandler），其中线程池SerialExecutor用于任务的排队，而线程池THREAD_POOL_EXECUTOR用于真正地执行任务，InternalHandler用于将执行环境从线程池切换到主线程。

sHandler是一个静态的Handler对象，为了能够将执行环境切换到主线程，这就要求sHandler这个对象必须在主线程创建。由于静态成员会在加载类的时候进行初始化，因此这就变相要求AsyncTask的类必须在主线程中加载，否则同一个进程中的AsyncTask都将无法正常工作。

4、IntentService有什么用 ？

IntentService可用于执行后台耗时的任务，当任务执行完成后会自动停止，同时由于IntentService是服务的原因，不同于普通Service，IntentService可自动创建子线程来执行任务，这导致它的优先级比单纯的线程要高，不容易被系统杀死，所以IntentService比较适合执行一些高优先级的后台任务。

5、直接在Activity中创建一个thread跟在service中创建一个thread之间的区别？

在Activity中被创建：该Thread的就是为这个Activity服务的，完成这个特定的Activity交代的任务，主动通知该Activity一些消息和事件，Activity销毁后，该Thread也没有存活的意义了。

在Service中被创建：这是保证最长生命周期的Thread的唯一方式，只要整个Service不退出，Thread就可以一直在后台执行，一般在Service的onCreate()中创建，在onDestroy()中销毁。所以，在Service中创建的Thread，适合长期执行一些独立于APP的后台任务，比较常见的就是：在Service中保持与服务器端的长连接。

6、ThreadPoolExecutor的工作策略 ？

ThreadPoolExecutor执行任务时会遵循如下规则：

• 如果线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行任务。

• 如果线程池中的线程数量已经达到或则超过核心线程的数量，那么任务会被插入任务队列中排队等待执行。

• 如果在第2点无法将任务插入到任务队列中，这往往是由于任务队列已满，这个时候如果在线程数量未达到线程池规定的最大值，那么会立刻启动一个非核心线程来执行任务。

• 如果第3点中线程数量已经达到线程池规定的最大值，那么就拒绝执行此任务，ThreadPoolExecutor会调用RejectedExecutionHandler的rejectedExecution方法来通知调用者。

7、Handler、Thread和HandlerThread的差别？

参考回答：Handler：在android中负责发送和处理消息，通过它可以实现其他支线线程与主线程之间的消息通讯。

Thread：Java进程中执行运算的最小单位，亦即执行处理机调度的基本单位。某一进程中一路单独运行的程序。

HandlerThread：一个继承自Thread的类HandlerThread，Android中没有对Java中的Thread进行任何封装，而是提供了一个继承自Thread的类HandlerThread类，这个类对Java的Thread做了很多便利的封装。HandlerThread继承于Thread，所以它本质就是个Thread。与普通Thread的差别就在于，它在内部直接实现了Looper的实现，这是Handler消息机制必不可少的。有了自己的looper，可以让我们在自己的线程中分发和处理消息。如果不用HandlerThread的话，需要手动去调用Looper.prepare()和Looper.loop()这些方法。

8、ThreadLocal的原理：

ThreadLocal是一个关于创建线程局部变量的类。使用场景如下所示：

• 实现单个线程单例以及单个线程上下文信息存储，比如交易id等。

• 实现线程安全，非线程安全的对象使用ThreadLocal之后就会变得线程安全，因为每个线程都会有一个对应的实例。承载一些线程相关的数据，避免在方法中来回传递参数。

当需要使用多线程时，有个变量恰巧不需要共享，此时就不必使用synchronized这么麻烦的关键字来锁住，每个线程都相当于在堆内存中开辟一个空间，线程中带有对共享变量的缓冲区，通过缓冲区将堆内存中的共享变量进行读取和操作，ThreadLocal相当于线程内的内存，一个局部变量。每次可以对线程自身的数据读取和操作，并不需要通过缓冲区与 主内存中的变量进行交互。并不会像synchronized那样修改主内存的数据，再将主内存的数据复制到线程内的工作内存。ThreadLocal可以让线程独占资源，存储于线程内部，避免线程堵塞造成CPU吞吐下降。

在每个Thread中包含一个ThreadLocalMap，ThreadLocalMap的key是ThreadLocal的对象，value是独享数据。

9、多线程是否一定会高效（优缺点）

多线程的优点：

• 方便高效的内存共享 - 多进程下内存共享比较不便，且会抵消掉多进程编程的好处

• 较轻的上下文切换开销 - 不用切换地址空间，不用更改CR3寄存器，不用清空TLB

• 线程上的任务执行完后自动销毁

多线程的缺点：

• 开启线程需要占用一定的内存空间(默认情况下,每一个线程都占512KB)

• 如果开启大量的线程,会占用大量的内存空间,降低程序的性能

• 线程越多,cpu在调用线程上的开销就越大

• 程序设计更加复杂,比如线程间的通信、多线程的数据共享

综上得出，多线程不一定能提高效率，在内存空间紧张的情况下反而是一种负担，因此在日常开发中，应尽量：

• 不要频繁创建，销毁线程，使用线程池

• 减少线程间同步和通信（最为关键）

• 避免需要频繁共享写的数据

• 合理安排共享数据结构，避免伪共享（false sharing）

• 使用非阻塞数据结构/算法

• 避免可能产生可伸缩性问题的系统调用（比如mmap）

• 避免产生大量缺页异常，尽量使用Huge Page

• 可以的话使用用户态轻量级线程代替内核线程

10、多线程中,让你做一个单例,你会怎么做？

多线程中建立单例模式考虑的因素有很多，比如线程安全 -延迟加载-代码安全:如防止序列化攻击，防止反射攻击(防止反射进行私有方法调用) -性能因素

实现方法有多种，饿汉，懒汉(线程安全，线程非安全)，双重检查(DCL),内部类，以及枚举

推荐文章：单例模式的总结（https://xxxblank.github.io/2017/09/14/singleTon/）

11、除了notify还有什么方式可以唤醒线程？

参考回答：当一个拥有Object锁的线程调用 wait()方法时，就会使当前线程加入object.wait 等待队列中，并且释放当前占用的Object锁，这样其他线程就有机会获取这个Object锁，获得Object锁的线程调用notify()方法，就能在Object.wait 等待队列中随机唤醒一个线程（该唤醒是随机的与加入的顺序无关，优先级高的被唤醒概率会高）

如果调用notifyAll（）方法就唤醒全部的线程。注意:调用notify()方法后并不会立即释放object锁，会等待该线程执行完毕后释放Object锁。

12、什么是ANR ? 什么情况会出现ANR ？如何避免 ？在不看代码的情况下如何快速定位出现ANR问题所在 ？

• ANR（Application Not Responding，应用无响应）：当操作在一段时间内系统无法处理时，会在系统层面会弹出ANR对话框

• 产生ANR可能是因为5s内无响应用户输入事件、10s内未结束BroadcastReceiver、20s内未结束Service

• 想要避免ANR就不要在主线程做耗时操作，而是通过开子线程，方法比如继承Thread或实现Runnable接口、使用AsyncTask、IntentService、HandlerThread等

1、Bitmap使用需要注意哪些问题 ？

要选择合适的图片规格（bitmap类型）：通常我们优化Bitmap时，当需要做性能优化或者防止OOM，我们通常会使用RGB_565，因为ALPHA_8只有透明度，显示一般图片没有意义，Bitmap.Config.ARGB_4444显示图片不清楚，Bitmap.Config.ARGB_8888占用内存最多。：

• ALPHA_8   每个像素占用1byte内存

• ARGB_4444 每个像素占用2byte内存

• ARGB_8888 每个像素占用4byte内存（默认）

• RGB_565 每个像素占用2byte内存

降低采样率：BitmapFactory.Options 参数inSampleSize的使用，先把options.inJustDecodeBounds设为true，只是去读取图片的大小，在拿到图片的大小之后和要显示的大小做比较通过calculateInSampleSize()函数计算inSampleSize的具体值，得到值之后。options.inJustDecodeBounds设为false读图片资源。

复用内存：即通过软引用(内存不够的时候才会回收掉)，复用内存块，不需要再重新给这个bitmap申请一块新的内存，避免了一次内存的分配和回收，从而改善了运行效率。

使用recycle()方法及时回收内存。

压缩图片。

2、Bitmap.recycle()会立即回收么？什么时候会回收？如果没有地方使用这个Bitmap，为什么垃圾回收不会直接回收？

• 通过源码可以了解到，加载Bitmap到内存里以后，是包含两部分内存区域的。简单的说，一部分是Java部分的，一部分是C部分的。这个Bitmap对象是由Java部分分配的，不用的时候系统就会自动回收了

• 但是那个对应的C可用的内存区域，虚拟机是不能直接回收的，这个只能调用底层的功能释放。所以需要调用recycle()方法来释放C部分的内存

• bitmap.recycle()方法用于回收该Bitmap所占用的内存，接着将bitmap置空，最后使用System.gc()调用一下系统的垃圾回收器进行回收，调用System.gc()并不能保证立即开始进行回收过程，而只是为了加快回收的到来。

3、一张Bitmap所占内存以及内存占用的计算？

参考回答：Bitamp 所占内存大小 = 宽度像素 x （inTargetDensity / inDensity） x 高度像素 x （inTargetDensity / inDensity）x 一个像素所占的内存字节大小

    注：这里inDensity表示目标图片的dpi（放在哪个资源文件夹下），inTargetDensity表示目标屏幕的dpi，所以你可以发现inDensity和inTargetDensity会对Bitmap的宽高进行拉伸，进而改变Bitmap占用内存的大小。

在Bitmap里有两个获取内存占用大小的方法。

• getByteCount()：API12 加入，代表存储 Bitmap 的像素需要的最少内存。

• getAllocationByteCount()：API19 加入，代表在内存中为 Bitmap 分配的内存大小，代替了 getByteCount() 方法。

• 在不复用 Bitmap 时，getByteCount() 和 getAllocationByteCount 返回的结果是一样的。在通过复用 Bitmap 来解码图片时，那么 getByteCount() 表示新解码图片占用内存的大 小，getAllocationByteCount() 表示被复用 Bitmap 真实占用的内存大小

4、Android中缓存更新策略 ？

Android的缓存更新策略没有统一的标准，一般来说，缓存策略主要包含缓存的添加、获取和删除这三类操作，但不管是内存缓存还是存储设备缓存，它们的缓存容量是有限制的，因此删除一些旧缓存并添加新缓存，如何定义缓存的新旧这就是一种策略，不同的策略就对应着不同的缓存算法

比如可以简单地根据文件的最后修改时间来定义缓存的新旧，当缓存满时就将最后修改时间较早的缓存移除，这就是一种缓存算法，但不算很完美

5、LRU的原理 ？

参考回答：为减少流量消耗，可采用缓存策略。常用的缓存算法是LRU(Least Recently Used)：当缓存满时, 会优先淘汰那些近期最少使用的缓存对象。主要是两种方式：

• LruCache(内存缓存)：LruCache类是一个线程安全的泛型类：内部采用一个LinkedHashMap以强引用的方式存储外界的缓存对象，并提供get和put方法来完成缓存的获取和添加操作，当缓存满时会移除较早使用的缓存对象，再添加新的缓存对象。

• DiskLruCache(磁盘缓存)：通过将缓存对象写入文件系统从而实现缓存效果