Android面试专题整理

作者: 白茫茫的大地 | 来源:发表于2020-01-13 11:39 被阅读0次

fresco加载图片原理优势是什么

缓存怎么处理的

a、根据Uri在已解码的（Bitmap缓存）内存缓存中查找，找到了则返回Bitmap对象；如果没找到，则开启后台线程开始后续的工作。
b、根据Uri在未解码的内存缓存中查找，若找到了则解码，然后缓存到已解码的内存缓存中，并且返回Bitmap对象。
d、如果在未解码的内存缓存中没找到，则根据Uri在磁盘缓存中查找，若找到了则读取数据（byte数组），并缓存到未解码的内存缓存中，解码、然后缓存到已解码的内存缓存中，并且返回Bitmap对象。
e、如果在磁盘缓存中没找到，则从网络或者本地加载数据。加载完成后，依次缓存到磁盘缓存、未解码的内存缓存中。解码、然后缓存到已解码的内存缓存中，并且返回Bitmap对象。

bitmap 内存分配

在4.x及以下的系统上，Fresco的bitmap decode会把bitmap的pixel data（像素数据）放到一个“特殊的内存区域’ ”，这个特殊的内存区域其实就是ashmem
为什么在4.x及以下系统需要这样做？原因是如果Bitmap数量很多时会占用大量的内存（这里内存特指Java Heap），必然就会更加频繁的触发虚拟机进行GC，GC 会导致stop the world
怎么实现的？
- BitmapFactory.Options 的参数 inPurgeable能使bitmap的内存分配到ashmem上。inPurgeable的作用是，在KITKAT及以下，使用该参数的话，当系统需要回收内存的时候，bitmap的pixels可以被清除。好在的是，当pixels需要被重新访问的时候（例如bitmap draw或者调用getPixels()的时候），它们又可以重新被decode出来
- isPurgeable为true的图片，内存分配的时机和流程，只有当bitmap进行draw或者getPixels（这个大抵一致）的时候，bitmap 的pixels才进行实际的内存分配
- bitmap draw的整个流程看，操作都处于UI线程，由于存在耗时的操作，会导致drop frames
ART模式下，BitmapOptions的inBitmap和inTempStorage去优化内存使用。inBitmap是由上层的BitmapPool 去分配内存，inTempStorage是由 SynchronizedPool分配内存，都是用缓存池的方式分配和回收内存，做到对这些区域的内存可管理，减少各个不同地方自行分配内存。
为啥使用 Ashmem
- Java Heap：大小受系统限制，内存自动回收。
- Native Heap：大小不受系统限制，仅受物理内存限制，内存需要手动释放。
- Ashmem：大小不受系统限制，仅受物理内存限制，系统在需要的时候可以自动回收，也可以手动阻止回收。

data binding

原理
- 将xml文件拆分成两部分，一部分是数据文件，一部分是布局文件，在布局文件中，为每个View设置一个tag，数据文件中，标示了相对应的tag的View所需要使用的数据
- 根据上面的两个xml在编译时生成 ActivityDataBindBinding和BR类
- 在 ActivityDataBindBinding 当中，会更加tag对每一个View进行赋值
- 根据上面的xml对数据进行绑定操作 (executeBindings方法)
数据的实时刷新
- 在进行set的方法时候，最终会调用到 executeBindings方法

Android中动画的原理

帧动画
- animation-list --> AnimationDrawable
- 容易oom
view动画
- a.getTransformation方法会返回一个布尔值，表示是否需要继续动画，一旦为true，则父控件会重新计算需要动画需要刷新的区域并且更新该区域。在动画结束之前会不断重绘，从而形成连续的动画效果。
- getTransformation 在这个方法中，根据流逝的时间计算当前动画时间百分比，然后通过插值器（Interpolator）重新计算这个百分比，并且以此来计算当前动画属性值
属性动画
- 属性动画是通过VSYNC信号来持续改变属性值进行动画的
- 相比于补间动画，属性动画重绘明显会少很多
- 流程 ObjectAnimator.ofFloat(button,"translationX",0,200);
  - 首先会把我们传入的View保存起来
  - 然后会初始化一个Holder对象，这个Holder对象是用来干啥的呢？我们传入了一个translationX值，Holder对象中提供一个方法，把translationX拼接成一个set方法，setTranslationX，然后通过反射找到View中的此方法。当数值计算出来之后，执行获取的这个方法。
  - KeyframeSet是一个关键帧的集合，最后我们传入0-200就是关键帧
  - 插值器，用来计算某一时间中动画长度播放的百分比
  - 估值器，根据插值器计算的百分比，来计算某个时间，动画所要更新的值。然后交给Holder执行动画
  - 属性动画会监听系统发出的VSYNC信号，每收到一次信号就执行一次
插值器和估值器
- 插值器：设置属性值从初始值过渡到结束值的变化规律
- 估值器：设置属性值从初始值过渡到结束值的变化具体数值
- 插值器只是根据时间百分比计算出一个属性值百分比，而把属性值百分比转换为真正属性值则交给估值器来做。例如：插值器返回的是一个百分比，估值器就可以将这个百分比转换成色值（0-255）或者一个坐标

touch事件分发

事件处理都是在 onTouchEvent 里面做的，这一点需要先理解，举个简单的例子，我点击一个按钮，有点击事件的回调，这个点击事件就是在onTouch里面处理的，所有的子View消费了这个事件，大致可以理解为，子View自己处理了touch事件，父View就别处理了，子View处理了点击事件，父View就别处理点击事件了

dispatchTouchEvent

事件分发

Activity的dispatchTouchEvent方法,下面看一下伪代码：

public boolean dispatchTouchEvent(MotionEvent ev) {
    if (child.dispatchTouchEvent(ev)) {
        return true;    //如果子View消费了该事件,则返回TRUE，让调用者知道该事件已被消费
    } else {
        return onTouchEvent(ev);    //如果子View没有消费该事件，则调用自身的onTouchEvent尝试处理。
    }
}

如果返回了true，就说明子View消费了这个事件，就不会调用 onTouchEvent 方法

ViewGroud的dispatchTouchEvent方法

public boolean dispatchTouchEvent(MotionEvent ev) {
    if (!onInterceptTouchEvent(ev)) {
        return child.dispatchTouchEvent(ev);    //不拦截，则传给子View进行分发处理
    } else {
        return onTouchEvent(ev);    //拦截事件，交由自身对象的onTouchEvent方法处理
    }
}

如果拦截了触摸事件，则就会调用自己的 onTouchEvent 方法，如果不拦截，就遍历自己子view,发现自己的符合某个条件，就调用子View的dispatchTouchEvent方法

View的dispatchTouchEvent方法

public boolean dispatchTouchEvent(MotionEvent ev) {
    //如果该对象的监听成员变量不为空，则会调用其onTouch方法，
    if (mOnTouchListener != null && mOnTouchListener.onTouch(this, event)) {
        return true;    //若onTouch方法返回TRUE，则表示消费了该事件，则dispachtouTouchEvent返回TRUE，让其调用者知道该事件已被消费。
    }
    return onTouchEvent(ev);    //若监听成员为空或onTouch没有消费该事件，则调用对象自身的onTouchEvent方法处理。
}

若listener的onTouch方法返回TRUE，则dispatchTouchEvent也会返回TRUE，表示消费该事件。不会调用onTouchEvent方法了

整体代码流程

///////////ViewGroup
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
       ...省略部分代码
        boolean handled = false;
        if (onFilterTouchEventForSecurity(ev)) {
            final int action = ev.getAction();
            final int actionMasked = action & MotionEvent.ACTION_MASK;
            //如果是DOWN事件,清除标记,恢复一些标记状态
            if (actionMasked == MotionEvent.ACTION_DOWN) {
                cancelAndClearTouchTargets(ev);
                resetTouchState();
            }

            //判断是否拦截
            final boolean intercepted;
            //触发DOWN事件或者mFirstTouchTarget不是Null,才会走if里面的逻辑
            if (actionMasked == MotionEvent.ACTION_DOWN
                    || mFirstTouchTarget != null) {
                // 子View可以通知父View，不要拦截
                final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
                if (!disallowIntercept) {
                    intercepted = onInterceptTouchEvent(ev);
                    ev.setAction(action); // restore action in case it was changed
                } else { // 不拦截
                    intercepted = false;
                }
            } else {
                // There are no touch targets and this action is not an initial down
                // so this view group continues to intercept touches.
                //不是DOWN事件 mFirstTouchTarget为空  拦截后续事件
                intercepted = true;
            }

             ...省略部分代码

            final boolean canceled = resetCancelNextUpFlag(this)
                    || actionMasked == MotionEvent.ACTION_CANCEL;

            // Update list of touch targets for pointer down, if needed.
            final boolean split = (mGroupFlags & FLAG_SPLIT_MOTION_EVENTS) != 0;
            TouchTarget newTouchTarget = null;
            boolean alreadyDispatchedToNewTouchTarget = false;
            //事件没有被取消或者没有被拦截执行if中逻辑
            if (!canceled && !intercepted) {
                View childWithAccessibilityFocus = ev.isTargetAccessibilityFocus()
                        ? findChildWithAccessibilityFocus() : null;

                if (actionMasked == MotionEvent.ACTION_DOWN
                        || (split && actionMasked == MotionEvent.ACTION_POINTER_DOWN)
                        || actionMasked == MotionEvent.ACTION_HOVER_MOVE) {
                    final int actionIndex = ev.getActionIndex(); // always 0 for down
                    final int idBitsToAssign = split ? 1 << ev.getPointerId(actionIndex)
                            : TouchTarget.ALL_POINTER_IDS;

                    // Clean up earlier touch targets for this pointer id in case they
                    // have become out of sync.
                    removePointersFromTouchTargets(idBitsToAssign);

                    final int childrenCount = mChildrenCount;
                    // 
                    if (newTouchTarget == null && childrenCount != 0) {
                        final float x = ev.getX(actionIndex);
                        final float y = ev.getY(actionIndex);
                        // Find a child that can receive the event.
                        // 从前到后为View进行排序
                        final ArrayList<View> preorderedList = buildTouchDispatchChildList();
                        final boolean customOrder = preorderedList == null && isChildrenDrawingOrderEnabled();
                        final View[] children = mChildren;
                        // 遍历排序后的View，进入淘汰机制
                        for (int i = childrenCount - 1; i >= 0; i--) {
                            final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
                            final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);
                            ...
                            //判断child是否可以响应事件 是否点击在了View的范围之内，如果不是的话，就不会进行下面的操作，也就不会有touch事件的调用
                            if (!canViewReceivePointerEvents(child)
                                    || !isTransformedTouchPointInView(x, y, child, null)) {
                                ev.setTargetAccessibilityFocus(false);
                                continue;
                            }
                            //获取上次响应事件的View,DOWN事件时候newTouchTarget为Null
                            newTouchTarget = getTouchTarget(child);
                            if (newTouchTarget != null) {
                                // Child is already receiving touch within its bounds.
                                // Give it the new pointer in addition to the ones it is handling.
                                newTouchTarget.pointerIdBits |= idBitsToAssign;
                                break;
                            }

                            resetCancelNextUpFlag(child);
                            //很重要的一个方法,在下面我们会看这个方法做了什么
                            if (dispatchTransformedTouchEvent(ev, false, child, idBitsToAssign)) { 
                                // 消费了这个事件，如果消费了这个事件。会为newTouchTarget赋值，mFirstTouchTarget赋值
                                // Child wants to receive touch within its bounds.
                                mLastTouchDownTime = ev.getDownTime();
                                if (preorderedList != null) {
                                    // childIndex points into presorted list, find original index
                                    for (int j = 0; j < childrenCount; j++) {
                                        if (children[childIndex] == mChildren[j]) {
                                            mLastTouchDownIndex = j;
                                            break;
                                        }
                                    }
                                } else {
                                    mLastTouchDownIndex = childIndex;
                                }
                                mLastTouchDownX = ev.getX();
                                mLastTouchDownY = ev.getY();
                                //在这个方法中把child赋值给了mFirstTouchTarget
                                newTouchTarget = addTouchTarget(child, idBitsToAssign);
                                alreadyDispatchedToNewTouchTarget = true;
                                break;
                            }                           
                            ev.setTargetAccessibilityFocus(false);
                        }
                        if (preorderedList != null) preorderedList.clear();
                    }

                   ...
                }
            }

            // Dispatch to touch targets.
            if (mFirstTouchTarget == null) { // 这里就标示没有要消费这个事件的View，如果没有，就调用自己的 dispatchTransformedTouchEvent 方法。这里的第三个参数为null
                // No touch targets so treat this as an ordinary view.
                handled = dispatchTransformedTouchEvent(ev, canceled, null,TouchTarget.ALL_POINTER_IDS);
            } else {
                // Dispatch to touch targets, excluding the new touch target if we already
                // dispatched to it.  Cancel touch targets if necessary.
                TouchTarget predecessor = null;
                TouchTarget target = mFirstTouchTarget;
                while (target != null) {
                    final TouchTarget next = target.next;
                    if (alreadyDispatchedToNewTouchTarget && target == newTouchTarget) {
                        handled = true;
                    } else {
                        final boolean cancelChild = resetCancelNextUpFlag(target.child)
                                || intercepted;
                        // 这里调用子View的dispatch事件
                        if (dispatchTransformedTouchEvent(ev, cancelChild,
                                target.child, target.pointerIdBits)) {
                            handled = true;
                        }
                        if (cancelChild) {
                            if (predecessor == null) {
                                mFirstTouchTarget = next;
                            } else {
                                predecessor.next = next;
                            }
                            target.recycle();
                            target = next;
                            continue;
                        }
                    }
                    predecessor = target;
                    target = next;
                }
            }

            ...
        }    

        ...
        return handled;
    }
    
    
    
    //最重要的几行代码的逻辑
    private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
            View child, int desiredPointerIdBits) {
        final boolean handled;
        ...省略部分代码
        // Perform any necessary transformations and dispatch.
        //child为空调用父View的dispatchTouchEvent
        if (child == null) {
            handled = super.dispatchTouchEvent(transformedEvent);
        } else {
            ...
            //child不为空调用child的dispatchTouchEvent方法
            handled = child.dispatchTouchEvent(transformedEvent);
        }
        ...
        return handled;
    }

    ////////// ViewGroup
     public boolean onInterceptTouchEvent(MotionEvent ev) {
        if (ev.isFromSource(InputDevice.SOURCE_MOUSE)
                && ev.getAction() == MotionEvent.ACTION_DOWN
                && ev.isButtonPressed(MotionEvent.BUTTON_PRIMARY)
                && isOnScrollbarThumb(ev.getX(), ev.getY())) {
            return true;
        }
        return false;
    }
    ////////// View
     public boolean dispatchTouchEvent(MotionEvent event) {
        ...

        boolean result = false;
        ...

        if (onFilterTouchEventForSecurity(event)) {
            if ((mViewFlags & ENABLED_MASK) == ENABLED && handleScrollBarDragging(event)) {
                result = true;
            }
            //noinspection SimplifiableIfStatement
            ListenerInfo li = mListenerInfo;
            //我们看到有mOnTouchListener,并且onTouch返回true,就没有onTouchEvent啥事了
            if (li != null && li.mOnTouchListener != null
                    && (mViewFlags & ENABLED_MASK) == ENABLED
                    && li.mOnTouchListener.onTouch(this, event)) {
                result = true;
            }

            if (!result && onTouchEvent(event)) {
                result = true;
            }
        }

       ...
        return result;
    }
    
    public boolean onTouchEvent(MotionEvent event) {
       ...
       // 一点击的话，项目返回为true，自己消费事件
        if (clickable || (viewFlags & TOOLTIP) == TOOLTIP) {
            ...
            return true;
        }

        return false;
    }

几点结论

跟踪一下down事件：所有的touch事件回调都会执行，所以down事件是都会接受到的
如果某个被点击的 textView 的 down 事件在onTouchEvent方法中返回了false，就会导致 dispatchTouchEvent 返回false，他的父类dispatchTransformedTouchEvent返回了false, mFirstTouchTarget==null，返回就会调用自己的onTouchEvent方法
如果 onInterceptTouchEvent 返回true，此时如果有后续事件过来，mFirstTouchTarget==null intercepted==true，这时候，就不会调用 dispatchTransformedTouchEvent 了，只会调用父类自己的 onTouchEvent方法
如果 disallowIntercept 为true，就不会调用 onInterceptTouchEvent 方法了
如果有设置TouchListener并且 mOnTouchListener.onTouch()返回的是 true，那么，onTouchEvent 将不会执行，所以onClick也不会执行
cancel事件的触发：
- 当用户保持按下操作，并从你的控件转移到外层控件时，会触发ACTION_CANCEL
- 当前控件(子控件)收到前驱事件(ACTION_MOVE或者ACTION_MOVE)后，它的父控件突然插手，截断事件的传递，这时，当前控件就会收到ACTION_CANCEL
参考了一些资料资料

ANR产生的原因

出现时机
- 输入事件(按键和触摸事件) 5s 内没被处理；
- BroadcastReceiver 的事件 ( onRecieve() 方法) 在规定时间内没处理完 (前台广播为 10s，后台广播为 60s)；
- Service 前台 20s 后台 200s 未完成启动；
- ContentProvider 的 publish() 在 10s 内没进行完。
ANR 的分析方法
- 使用 adb 导出 ANR 日志并进行分析 traces.txt
- 使用 DDMS 的 traceview 进行分析
- 使用开源项目 ANR-WatchDog 来检測 ANR
常见的 ANR 场景
- I/O 阻塞
- 网络阻塞
- 多线程死锁
- 由于响应式编程等导致的方法死循环
- 由于某个业务逻辑执行的时间太长
避免 ANR 的方法
- UI 线程尽量只做跟 UI 相关的工作；
- 耗时的工作 (比如数据库操作，I/O，网络操作等)，采用单独的工作线程处理；
- 用 Handler 来处理 UI 线程和工作线程的交互；
- 使用 RxJava 等来处理异步消息。
- 总之，一个原则就是：不在主线程做耗时操作

SpareArray

底层是两条数组，一组存放key，一组存放value
于hashMap相比：使用int[]数组存放key，避免了HashMap中基本数据类型需要装箱的步骤，其次不使用额外的结构体（Entry)，单个元素的存储成本下降。
插入过程
- 存放keys的数组是有序的，在put的时候是通过二分查找找到的index
- 如果冲突，新值直接覆盖原值，并且不会返回原值
- 如果当前要插入的 key 的索引上的值为DELETE，直接覆盖，例如：mKeys中并没有 3 这个值，但是通过二分查找得出来，目前应该插入的索引位置为 2 ，但是此时index=2的位置上的key=4，而当前这个位置上对应的value标记为DELETED了，所以会直接将该位置上的key赋值为 3 ，并且将该位置上的value赋值为put()传入的对象。
- 前几步都失败了，检查是否需要gc()并且在该索引上插入数据，例如：数组已经满容量了，而且 3 应该插入的位置已经有 4 了，而 5 所指向的值为DELETED，这种情况下，会先去回收DELETED,重新调整数组结构,然后再重新计算 3 应该插入的位置
- 如果上面几部都无法插入，此时就可以扩容了
remove操作其实是将对应的value值设置为了一个固定的值DELETE，key仍然保存在数组中，目的应该是为了保持索引结构，同时不会频繁压缩数组，保证索引查询不会错位
gc 删除无用的key
优势：
- 避免了基本数据类型的装箱操作
- 不需要额外的结构体，单个元素的存储成本更低
- 数据量小的情况下，随机访问的效率更高
缺点
- 插入操作需要复制数组，增删效率降低
- 数据量巨大时，复制数组成本巨大，gc()成本也巨大
- 数据量巨大时，查询效率也会明显下降
参考

Eventbus

整体流程
- 注册
  - 通过反射或者注解的方式，或者订阅者所有的订阅方法
  - 将当前订阅者添加到EventBus总的事件订阅者集合中
  - 将当前订阅者所有订阅的事件类型添加到typeBySubscriber中
- 发送
  - 得到要发送事件的类型
  - 根据事件类型获取所有订阅者，循环向每个订阅者发送消息
- 反注册
  - 通过typeBySubscriber获取当前订阅者所有的事件类型
  - 循环遍历每一个事件类型，并删除当前订阅者的订阅方法
关于订阅方法
- 允许一个类有多个参数相同的订阅方法。
- 子类继承并重写了父类的订阅方法，那么只会把子类的订阅方法添加到订阅者列表，父类的方法会忽略。

// 子类调用的时候 methodClassOld 为空，
// 父类的时候 methodClassOld(此时为子类)不为空，并且methodClassOld.isAssignableFrom(methodClass)为false,此时返回为false，并且 subscriberClassByMethodKey 里面为子类
Class<?> methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
    // Only add if not already found in a sub class
    return true;
} else {
    // Revert the put, old class is further down the class hierarchy
    subscriberClassByMethodKey.put(methodKey, methodClassOld);
    return false;
}

post一个事件
- 如果事件继承自父类，那么父类也会作为事件被发送
- 粘性事件：先发送出去，然后让后面注册的订阅者能够收到该事件，在注册的时候有对粘性事件的处理
- 如何进行线程切换的？
  - 主线程：通过HandlerPoster, HandlerPoster 继承自 Handler,该handler内部有一个PendingPostQueue，这是一个队列，保存了PendingPost，即待发送的post，该PendingPost封装了event和subscription，通过sendMessage来发送处理消息
  - 子线程：通过BackgroundPoster，BackgroundPoster继承自Runnable，内部有PendingPostQueue这个队列，通过eventBus.getExecutorService().execute(this);来处理方法的调用
  - 异步线程，AsyncPoster，是一个Runnable，实现原理与BackgroundPoster大致相同，它内部不用判断之前是否已经有一条线程已经在运行了，它每次post事件都会使用新的一条线程。
优缺点
- 优点：独立出一个发布订阅模块，调用者可以通过使用这个模块，屏蔽一些线程切换问题，简单地实现发布订阅功能
- 缺点：大量的滥用，将导致逻辑的分散，出现问题后很难定位。代码可读性差

Handler

Handler Looper MessageQueue
- Looper ：负责关联线程以及消息的分发在该线程下**从 MessageQueue 获取 Message，分发给 Handler ；
- MessageQueue ：是个队列，负责消息的存储与管理，负责管理由 Handler 发送过来的 Message ；
- Handler : 负责发送并处理消息，面向开发者，提供 API，并隐藏背后实现的细节。
postDelayed的原理
- 1.消息是通过MessageQueen中的enqueueMessage()方法加入消息队列中的，并且它在放入中就进行好排序，链表头的延迟时间小，尾部延迟时间最大
- 2.Looper.loop()通过MessageQueue中的next()去取消息
- 3.next()中如果当前链表头部消息是延迟消息，则根据延迟时间进行消息队列会阻塞，不返回给Looper message，知道时间到了，返回给message
- 4.如果在阻塞中有新的消息插入到链表头部则唤醒线程
- 5.Looper将新消息交给回调给handler中的handleMessage后，继续调用MessageQueen的next()方法，如果刚刚的延迟消息还是时间未到，则计算时间继续阻塞
为什么不允许在子线程中访问UI
- 因为Android的UI控件并不是线程安全的,如果多线程中并发访问可能导致UI控件处于不可预期的状态。加锁可不可以呢？加上锁机制会让UI访问的逻辑变得复杂;其次锁机制会降低UI访问的效率,因为锁机制会阻塞某些线程的执行.
Looper.myLooper() 是如何获取到当前线程的Looper的？
- myLooper()内部使用ThreadLocal实现，因此能够获取各个线程自己的Looper
MessageQueue中底层是采用的队列
- 采用单链表的数据结构来维护消息队列，而不是采用队列
MessageQueue.next() 会因为发现了延迟消息，而进行阻塞。那么为什么后面加入的非延迟消息没有被阻塞呢？
- 调用 MessageQueue.next() 方法的时候会调用 Native 层的 nativePollOnce() 方法进行精准时间的阻塞。在 Native 层，将进入 pullInner() 方法，使用 epoll_wait 阻塞等待以读取管道的通知。如果没有从 Native 层得到消息，那么这个方法就不会返回。此时主线程会释放 CPU 资源进入休眠状态。
- 当我们加入消息的时候，会调用 MessageQueue.enqueueMessage() 方法，添加完 Message 后，如果消息队列被阻塞，则会调用 Native 层的 nativeWake() 方法去唤醒。它通过向管道中写入一个消息，结束上述阻塞，触发上面提到的 nativePollOnce() 方法返回，好让加入的 Message 得到分发处理。
Handler 的 dispatchMessage() 分发消息的处理流程？
- 使用 Handler 的时候我们会覆写 Handler 的 handleMessage() 方法。当我们调用该 Handler 的 send() 或者 post() 发送一个消息的时候，发送的信息会被包装成 Message，并且将该 Message 的 target 指向当前 Handler，这个消息会被放进 Looper 的 MQ 中。然后在 Looper 的循环中，取出这个 Message，并调用它的 target Handler，也就是我们定义的 Handler 的 dispatchMessage() 方法处理消息，此时会调用到 Handler 的 handleMessage() 方法处理消息，并回调 Callback.
Looper 中的 quit() 和 quitSafely() 有什么区别
- quit() 和 quitSafely() 的本质就是让消息队列的 next() 返回 null，以此来退出Looper.loop()。
- quit() 调用后直接终止 Looper，不在处理任何 Message，所有尝试把 Message 放进消息队列的操作都会失败，比如 Handler.sendMessage() 会返回 false，但是存在不安全性，因为有可能有 Message 还在消息队列中没来的及处理就终止 Looper 了。
- quitSafely() 调用后会在所有消息都处理后再终止 Looper，所有尝试把 Message 放进消息队列的操作也都会失败。
Looper.loop() 在什么情况下会退出？
- 1. next() 方法返回的 msg == null；2) 线程意外终止。
如何保证一个线程最多只能有一个 Looper？如何保证只有一个 MessageQueue
- 通过保证只有一个 Looper 来保证只有以一个 MQ. 在一个线程中使用 Handler 之前需要使用 Looper.prepare() 创建 Looper，它会从 ThreadLocal 中获取，如果发现 ThreadLocal 中已经存在 Looper，就抛异常。
一个 Looper 是如何区分多个 Handler 的？
- Looper 不会区分 Handler，每个 Handler 会被添加到 Message 的 target 字段上面，Looper 通过调用 Message.target.handleMessage() 来让 Handler 处理消息。

Android面试专题整理

fresco加载图片原理优势是什么

缓存怎么处理的

bitmap 内存分配

data binding

Android中动画的原理

touch事件分发

dispatchTouchEvent

整体代码流程

几点结论

ANR产生的原因

SpareArray

Eventbus

Handler

okhttp

LRUCache

RxJava 功能与原理实现,与平时使用的异步操作来比，优势,优缺点

插件化

热修复

图片的加载问题

Binder机制

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

android面试录

Android面试专题整理

fresco加载图片原理 优势是什么

缓存怎么处理的

bitmap 内存分配

data binding

Android中动画的原理

touch事件分发

dispatchTouchEvent

整体代码流程

几点结论

ANR产生的原因

SpareArray

Eventbus

Handler

okhttp

LRUCache

RxJava 功能与原理实现,与平时使用的异步操作来比，优势,优缺点

插件化

热修复

图片的加载问题

Binder机制

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

android面试录

fresco加载图片原理优势是什么