Android开发高频面试题之——Android篇

Android开发高频面试题之——Android篇

Android开发高频面试题之——Java基础篇
Android开发高频面试题之——Kotlin基础篇
Android开发高频面试题之——Android基础篇

1. Activity启动模式

  • standard 标准模式，每次都是新建Activity实例。
  • singleTop 栈顶复用。如果要启动的Activity已经处于任务栈顶，则直接复用不会新建Activity实例，此时会调用onNewIntent方法。如果栈内不存在或者不在栈顶。则会新建Activity实例。
  • singleTask 栈内单例。如果任务栈内已经存在Activity实例，则直接复用。如果不在栈顶，则把该activity实例之上的全部出栈，让自身位于栈顶。此时会调用onNewIntent方法。
  • singleInstance 新建任务栈栈内唯一。应用场景：来电话界面,即使来多个电话也只创建一个Activity;

2. Activity生命周期

在这里插入图片描述

  • 启动状态（Starting）：Activity的启动状态很短暂，当Activity启动后便会进入运行状态（Running）。
  • 运行状态（Running）：Activity在此状态时处于屏幕最前端，它是可见、有焦点的，可以与用户进行交互。如单击、长按等事件。即使出现内存不足的情况，Android也会先销毁栈底的Activity，来确保当前的Activity正常运行。
  • 暂停状态（Paused）：在某些情况下，Activity对用户来说仍然可见，但它无法获取焦点，用户对它操作没有没有响应，此时它处于暂停状态。例如，当前Activity弹出Dialog，或者新启动Activity为透明的Activity等情况。
  • 停止状态（Stopped）：当Activity完全不可见时，它处于停止状态，但仍然保留着当前的状态和成员信息。如系统内存不足，那么这种状态下的Activity很容易被销毁。
  • 销毁状态（Destroyed）：当Activity处于销毁状态时，将被清理出内存。

Activity的生命周期
在这里插入图片描述

  • onCreate() ： 在Activity创建时调用，通常做一些初始化设置，不可以执行耗时操作。；
  • onNewIntent()*：注意 ！！只有当 当前activity实例已经处于任务栈顶，并且使用启动模式为singleTop或者SingleTask再次启动Activity时才会调用此方法。此时不会走OnCreate()，而是会执行onNewIntent()。因为activity不需要创建而是直接复用。
  • onStart()： 在Activity即将可见时调用；可以做一些动画初始化的操作。
  • onRestoreInstanceState()*：注意 ！！当app异常退出重建时才会调用此方法。可以在该方法中恢复以保存的数据。
  • onResume()： 在Activity已可见，获取焦点开始与用户交互时调用；当Activity第一次启动完成或者当前Activity被遮挡住一部分（进入了onPause()）重新回到前台时调用，比如弹窗消失。当onResume()方法执行完毕之后Activity就进入了运行状态。根据官方的建议，此时可以做开启动画和独占设备的操作。
  • onPause()： 在当前Activity被其他Activity覆盖或锁屏时调用；Activity停止但是当前Activity还是处于用户可见状态，比如出现弹窗；在onPause()方法中不能进行耗时操作（当前Activity通过Intent启动另一个Activity时，会先执行当前Activity的onPause()方法，再去执行另一个Activity的生命周期）
  • onSaveInstanceState()：注意 ！！ 只有当app可能会异常销毁时才会调用此方法保存activity数据。以便于activity重建时恢复数据
    Activity的onSaveInstanceState回调时机，取决于app的targetSdkVersion：
    targetSdkVersion低于11的app，onSaveInstanceState方法会在Activity.onPause之前回调；
    targetSdkVersion低于28的app，则会在onStop之前回调；
    28之后，onSaveInstanceState在onStop回调之后才回调。
  • onStop() ： 在Activity完全被遮挡对用户不可见时调用（在onStop()中做一些回收资源的操作）
  • onDestroy() ：在Activity销毁时调用；
  • onRestart() ： 在Activity从停止状态再次启动时调用；处于stop()状态也就是完全不可见的Activity重新回到前台时调用（重新回到前台不会调用onCreate()方法，因为此时Activity还未销毁）

Activity横竖屏切换生命周期
横竖屏切换涉及到的是Activity的android:configChanges属性;
android:configChanges可以设置的属性值有：

orientation：消除横竖屏的影响
keyboardHidden：消除键盘的影响
screenSize：消除屏幕大小的影响

  • 设置Activity的android:configChanges属性为orientation或者orientation|keyboardHidden或者不设置这个属性的时候，横竖屏切换会重新调用各个生命周期方法，切横屏时会执行1次，切竖屏时会执行1次；
  • 设置Activity的属性为 android:configChanges=“orientation|keyboardHidden|screenSize” 时，横竖屏切换不会重新调用各个生命周期方法，只会执行onConfigurationChanged方法；

3. 了解Service吗

Service一般用于没有ui界面的长期服务。
Service有两种启动方式

  • StartService 这种方式启动的Service生命周期和启动实例无关。启动后会一直存在，直到app退出，或者调用stopService或者stopSelf。生命周期为onCreate-》onStartCommand-》onDestroyed。
    • 多次启动StartService。onStartCommand会调用多次
  • bindService 这种方式启动的Service和生命周期会和调用者绑定。一旦调用者结束，Service也会一起结束。生命周期为onCreate-》onBind-》onUnbind-》onDestroyed

如何保证Service不被杀死

  • onStartCommand方式中，返回START_STICKY或者START_REDELIVER_INTENT
    • START_STICKY：如果返回START_STICKY，Service运行的进程被Android系统杀掉之后，Android系统会将该Service依然设置为started状态（即运行状态），会重新创建该Service。但是不再保存onStartCommand方法传入的intent对象
    • START_NOT_STICKY：如果返回START_NOT_STICKY，表示当Service运行的进程被Android系统强制杀掉之后，不会重新创建该Service
    • START_REDELIVER_INTENT：如果返回START_REDELIVER_INTENT，其返回情况与START_STICKY类似，但不同的是系统会保留最后一次传入onStartCommand方法中的Intent再次保留下来并再次传入到重新创建后的Service onStartCommand方法中
  • 提高Service的优先级： 在AndroidManifest.xml文件中对于intent-filter可以通过android:priority = "1000"这个属性设置最高优先级，1000是最高值，如果数字越小则优先级越低，同时适用于广播；
  • 在onDestroy方法里重启Service： 当service走到onDestroy()时，发送一个自定义广播，当收到广播 时，重新启动service；
  • 提升Service进程的优先级。 进程优先级由高到低：前台进程 一》 可视进程 一》 服务进程 一》 后台进程 一》 空进程
    可以使用 startForeground将service放到前台状态，这样低内存时，被杀死的概率会低一些； 系统广播监听Service状态将APK安装到/system/app，变身为系统级应用。

4. 使用过broadcastReceiver吗？

可分为标准广播（无序广播）和有序广播
按照作用范围可分为全局广播和本地广播
按照注册方式可分为静态广播和动态广播

  • 标准广播
    标准广播（normal broadcasts）是一种完全异步执行的广播，在广播发出之后，所有的BroadcastReceiver几乎都会在同一时刻接收到收到这条广播消息，因此它们之间没有任何先后顺序可言。这种广播的效率会比较高，但同时也意味着它是无法被截断的。
  • 有序广播
    有序广播（ordered broadcasts）是一种同步执行的广播，在广播发出之后，同一时刻只会有一个BroadcastReceiver能够收到这条广播消息，当这个BroadcastReceiver中的逻辑执行完毕后，广播才会继续传递。所以此时的BroadcastReceiver是有先后顺序的，优先级高的BroadcastReceiver就可以先收到广播消息，并且前面的BroadcastReceiver还可以截断正在传递的广播，这样后面的BroadcastReceiver就无法收到广播消息了。
    • 清单文件里的android:priority属性的数字大小设置优先级 范围为(-1000到1000)数字越大，优先级越高
    • setResultExtras(bundle) 向下游广播接收器传递额外的键值对信息或者**setResultData(“”)**直接传送字符串
    • 下游广播通过getResultExtras方法接收信息, getResultData() 方法接收字符串信息
    • abortBroadcast() 进行截断
        <receiverandroid:name=".broadcast.MyHaveBroadcastReceiver02"android:exported="true"><intent-filter android:priority="003"><action android:name="my_have_broadcast_receiver"></action></intent-filter></receiver>
/*** 有序广播*/
public class MyHaveBroadcastReceiver02 extends BroadcastReceiver {private static final String TAG = "MyHaveBroadcastReceiver02";@Overridepublic void onReceive(Context context, Intent intent) {if (intent != null) {Bundle extras = intent.getExtras();String data = "";if (extras != null) {data = extras.getString("name3");/*** 2.1有序广播可以通过setResultExtras向下游广播接收器传递数据*/extras.putString("name2", "喊你速速到龙阳路集合");setResultExtras(extras);/*** 2.2有序广播可以通过setResultData向下游广播接收器传递字符串*/setResultData("2号口的信息");}Log.d(TAG, "MyHaveBroadcastReceiver02 onReceive" + data);/*** 1.有序广播可以通过abortBroadcast();方法对广播进行截断*/
//            abortBroadcast();}}
}
  • 本地广播：发送的广播事件不被其他应用程序获取，也不能响应其他应用程序发送的广播事件。本地广播只能被动态注册，不能静态注册。动态注册或发送时时需要用到LocalBroadcastManager。
  • 全局广播：发送的广播事件可被其他应用程序获取，也能响应其他应用程序发送的广播事件（可以通过 exported–是否监听其他应用程序发送的广播 在清单文件中控制） 全局广播既可以动态注册，也可以静态注册。
  • 静态广播
    静态广播在清单文件AndroidMainfest.xml中注册，生命周期随系统，不受Activity生命周期影响，即使进程被杀死，仍然能收到广播，因此也可以通过注册静态广播做一些拉起进程的事。随着Android版本的增大，Android系统对静态广播的限制也越来越严格，一般能用动态广播解决的问题就不要用静态广播。
  • 动态广播
    动态广播不需要在AndroidManifest.xml文件中进行注册，动态注册的广播受Activity声明周期的影响，Activity消亡，广播也就不复存在。动态广播在需要接受广播的Activity中进行注册和解注册。

5. 说说你对handler的理解

Handler是Android用来解决线程间通讯问题的消息机制。Handler消息机制分为四个部分。

  • Handler 消息的发送者和处理者
  • Message 消息实体 消息的载体和携带者。
  • MessageQueen 消息队列，使用双向链表实现，是存放消息的队列。
  • Looper 消息循环器，不停的从消息队列中中取出消息。

如何使用Handler？

  • 使用Handler需要一个Looper环境，在主线程直接新建Handler实例然后实现handleMessage方法，然后在需要发送消息的地方，使用handler.sendMessage等方法即可。
private static class MyHandler extends Handler {private final WeakReference<MainActivity> mTarget;public MyHandler(MainActivity activity) {mTarget = new WeakReference<MainActivity>(activity);}@Overridepublic void handleMessage(@NonNull Message msg) {super.handleMessage(msg);HandlerActivity activity = weakReference.get();super.handleMessage(msg);if (null != activity) {//执行业务逻辑if (msg.what == 0) {Log.e("myhandler", "change textview");MainActivity ma = mTarget.get();ma.textView.setText("hahah");}Toast.makeText(activity,"handleMessage",Toast.LENGTH_SHORT).show();}}}private Handler handler1 = new MyHandler(this);new Thread(new Runnable() {@Overridepublic void run() {handler1.sendEmptyMessage(0);}}).start();
  • 在子线程使用需要先创建Looper环境，调用Looper.prepare()，然后再创建Handler。最后在调用Looper.loop()启动消息循环。子线程Handler不使用时要调用handler.getLooper().quitSafely()退出Looper否则会阻塞。
	private static class MyHandler extends Handler {@Overridepublic void handleMessage(@NonNull Message msg) {super.handleMessage(msg);if (msg.what == 0) {Log.e("child thread", "receive msg from main thread");}}}private Handler handler1;@Overrideprotected void onCreate(@Nullable Bundle savedInstanceState) {     new Thread(new Runnable() {@Overridepublic void run() {Looper.prepare(); //准备Looper环境handler1 = new MyHandler();Looper.loop(); //启动LooperLog.e("child thread", "child thread end");}}).start();handler1.sendEmptyMessage(0);handler1.getLooper().quitSafely();//子线程Handler不用时，退出Looper
}

主线程使用Handler为什么不用Looper.prepare()？

因为在app启动时，ActivityThread的Main方法里帮我们调用了Looper.prepareMainLooper()。并且最后调用了Looper.loop()
启动了主线程。

public static void main(String[] args) {Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");// Install selective syscall interceptionAndroidOs.install();// CloseGuard defaults to true and can be quite spammy.  We// disable it here, but selectively enable it later (via// StrictMode) on debug builds, but using DropBox, not logs.CloseGuard.setEnabled(false);Environment.initForCurrentUser();// Make sure TrustedCertificateStore looks in the right place for CA certificatesfinal File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());TrustedCertificateStore.setDefaultUserDirectory(configDir);// Call per-process mainline module initialization.initializeMainlineModules();Process.setArgV0("<pre-initialized>");Looper.prepareMainLooper();// Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.// It will be in the format "seq=114"long startSeq = 0;if (args != null) {for (int i = args.length - 1; i >= 0; --i) {if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {startSeq = Long.parseLong(args[i].substring(PROC_START_SEQ_IDENT.length()));}}}ActivityThread thread = new ActivityThread();thread.attach(false, startSeq);if (sMainThreadHandler == null) {sMainThreadHandler = thread.getHandler();}if (false) {Looper.myLooper().setMessageLogging(newLogPrinter(Log.DEBUG, "ActivityThread"));}// End of event ActivityThreadMain.Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);Looper.loop();throw new RuntimeException("Main thread loop unexpectedly exited");}

简述一下Handler的工作流程

  • Handler使用SendMessage或者post等方法。最终都会调用MessageQueue的enqueueMessage()方法。将消息按照执行时间先后顺序入队。
  • Looper里面是个死循环，不停地在队列中通过MessageQueue.next()方法取出消息，取出消息后，通过msg.target.dispatchMessage() 方法分发消息。先交给msg消息的runnable处理，再交给Handler的Callable处理，最后再交给Handler实现的handleMessage方法处理
    public void dispatchMessage(@NonNull Message msg) {if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}handleMessage(msg);}}

一个线程中最多有多少个Handler，Looper，MessageQueue？

  • 一个线程可以有多个Handler
  • 一个handler只能有一个Looper和一个MessageQueen
    因为创建Handler必须有Looper环境，而Looper只能通过Looper.prepare和Looper.prepareMainLooper来创建。同时将Looper实例存放到线程局部变量sThreadLocal(ThreadLocal)中，也就是每个线程有自己的Looper。在创建Looper的时候也创建了该线程的消息队列，prepareMainLooper会判断sMainLooper是否有值，如果调用多次，就会抛出异常，所以主线程的Looper和MessageQueue只会有一个。同理子线程中调用Looper.prepare()时，会调用prepare(true)方法，如果多次调用，也会抛出每个线程只能由一个Looper的异常，总结起来就是每个线程中只有一个Looper和MessageQueue。
    public static void prepare() {prepare(true);}private static void prepare(boolean quitAllowed) {if (sThreadLocal.get() != null) {throw new RuntimeException("Only one Looper may be created per thread");}sThreadLocal.set(new Looper(quitAllowed));}

Looper死循环为什么不会导致应用ANR、卡死，会耗费大量资源吗？

线程其实就是一段可执行的代码，当可执行的代码执行完成后，线程的生命周期便该终止了，线程退出。而对于主线程，我们是绝不希望会被运行一段时间，自己就退出，那么如何保证能一直存活呢？简单做法就是可执行代码是能一直执行下去的，死循环便能保证不会被退出

  • ANR 产生的原因是主线程没有及时响应用户的操作。也就是主线程执行某个耗时操作来不及处理UI消息。
  • 而Looper一直循环，就是在不断的检索消息，与主线程无法响应用户操作没有任何冲突
  • Android是基于消息处理机制的，用户的行为都在这个Looper循环中，正是有了主线程Looper的不断循环，才有app的稳定运行。
  • 简单来说looper的阻塞表明没有事件输入，而ANR是由于有事件没响应导致，所以looper的死循环并不会导致应用卡死。

主线程的死循环并不消耗 CPU 资源，这里就涉及到 Linux pipe/epoll机制，简单说就是在主线程的 MessageQueue 没有消息时，便阻塞在 loop 的 queue.next() 中的 nativePollOnce() 方法里，此时主线程会释放 CPU 资源进入休眠状态，直到下个消息到达或者有事务发生，通过往 pipe 管道写端写入数据来唤醒主线程工作。这里采用的 epoll 机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。 所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源。

Handler同步屏障了解吗

同步屏障是为了保证异步消息的优先执行，一般是用于UI绘制消息，避免主线程消息太多，无法及时处理UI绘制消息，导致卡顿。

  • 同步消息 一般的handler发送的消息都是同步消息
  • 异步消息 Message标记为异步的消息
    • 可以调用 Message#setAsynchronous() 直接设置为异步 Message
    • 可以用异步 Handler 发送 使用 Handler.createAsync() 创建异步Handler
    public static Handler createAsync(@NonNull Looper looper) {if (looper == null) throw new NullPointerException("looper must not be null");return new Handler(looper, null, true);}
  • 同步屏障 在 MessageQueue 的 某个位置放一个 target 属性为 null 的 Message ，确保此后的非异步 Message 无法执行，只能执行异步 Message。

当 Looper轮循MessageQueue 遍历 Message发现建立了同步屏障的时候，会去跳过其他Message，读取下个 async 的 Message 并执行，屏障移除之前同步 Message 都会被阻塞。
比如屏幕刷新 Choreographer 就使用到了同步屏障 ，确保屏幕刷新事件不会因为队列负荷影响屏幕及时刷新。
注意： 同步屏障的添加或移除 API MessageQueue.postSyncBarrier并未对外公开，App 需要使用的话需要依赖反射机制

    try {MessageQueue queue=handler.getLooper().getQueue();Method method=MessageQueue.class.getDeclaredMethod("postSyncBarrier");method.setAccessible(true);token= (int) method.invoke(queue);} catch (Exception e) {e.printStackTrace();}try {MessageQueue queue=handler.getLooper().getQueue();Method method=MessageQueue.class.getDeclaredMethod("removeSyncBarrier",int.class);method.setAccessible(true);method.invoke(queue,token);} catch (Exception e) {e.printStackTrace();}

Handler 为什么可能导致内存泄露？如何避免？

持有 Activity 实例的匿名内部类或内部类的 生命周期 应当和 Activity 保持一致，否则产生内存泄露的风险。

如果 Handler 使用不当，将造成不一致，表现为：匿名内部类或内部类写法的 Handler、Handler$Callback、Runnable，或者Activity 结束时仍有活跃的 Thread 线程或 Looper 子线程

具体在于：异步任务仍然活跃或通过发送的 Message 尚未处理完毕，将使得内部类实例的 生命周期被错误地延长 。造成本该回收的 Activity 实例 被别的 Thread 或 Main Looper 占据而无法及时回收 （活跃的 Thread 或 静态属性 sMainLooper 是 GC Root 对象）
建议的做法：

  • 无论是 Handler、Handler$Callback 还是 Runnable，尽量采用 静态内部类 + 弱引用 的写法，确保尽管发生不当引用的时候也可以因为弱引用能清楚持有关系
  • 另外在 Activity 销毁的时候及时地 终止 Thread、停止子线程的 Looper 或清空 Message ，确保彻底切断 Activity 经由 Message 抵达 GC Root 的引用源头（Message 清空后会其与 Handler 的引用关系，Thread 的终止将结束其 GC Root 的源头）

Handler是如何实现线程间通讯的

  • handler是消息的发送者也是处理者。发送消息时，msg.target会标记为自身。插入MessageQueen后，被Looper取出后会通过msg.target.dispatchMessage去分发给对应的Handler去处理。

Handler消息处理的优先级

    public void dispatchMessage(@NonNull Message msg) {if (msg.callback != null) {handleCallback(msg);} else {if (mCallback != null) {if (mCallback.handleMessage(msg)) {return;}}handleMessage(msg);}}

可以看出优先级是Message.CallBack->Handler.callback->Handler.handleMessage
有时候面试官也会问Runnable->Callable->handleMessage
post方法就是runnable
Handler构造传入Callback就是Callable
send方法是handleMessage

如何正确或Message实例

  • 通过 Message 的静态方法 Message.obtain() 获取；
  • 通过 Handler 的公有方法 handler.obtainMessage()
  • 默认大小是50

Message使用享元设计模式，里面有一个spool指向一个Message对象，还有一个next指向下一个Message，维护了一个链表实现的对象池，obtain的时候在表头头取Message，在Message回收的时候在表头添加一个Message。

Android 为什么不允许并发访问 UI？

Android 中 UI 非线程安全，并发访问的话会造成数据和显示错乱。
此限制的检查始于ViewRootImpl#checkThread()，其会在刷新等多个访问 UI 的时机被调用，去检查当前线程，非主线程的话抛出异常。（实际上并不是检查主线程。而是检查UI的更新线程是否与UI的创建线程一致，因为UI是在主线程创建的，所以也只能在主线程更新）
而 ViewRootImpl 的创建在 onResume() 之后，也就是说如果在 onResume() 执行前启动线程访问 UI 的话是不会报错的。

了解ThreadLocal吗

  • Thread中会维护一个类似HashMap的东西，然后用ThreadLocal对象作为key，value就是要存储的变量值，这样就保证了存储数据的唯一性）
  • ThreadLocal为每个线程都提供了变量的副本，使得每个线程在某一时间访问到的并非同一个对象，这样就隔离了多个线程对数据的数据共享。
  • ThreadLocal 内部通过 ThreadLocalMap 持有 Looper，key 为 ThreadLocal 实例本身，value 即为 Looper 实例
    每个 Thread 都有一个自己的 ThreadLocalMap，这样可以保证每个线程对应一个独立的 Looper 实例，进而保证 myLooper() 可以获得线程独有的 Looper。让每个线程方便程获取自己的 Looper 实例
    在这里插入图片描述

ThreadLocal与内存泄漏

  • 在线程池中使用ThreadLocal可能会导致内存泄漏，原因是线程池中线程的存活时间太长，往往和程序都是同生共死的，这就意味着Thread持有的ThreadLocalMap一直都不会被回收，再加上ThreadLocalMap中的Entry对ThreadLocal是弱引用，所以只要ThreadLocal结束了自己的生命周期是可以被回收掉的。但是Entry中的Value却是被Entry强引用的，所以即便Value的生命周期结束了，Value也是无法被回收的，从而导致内存泄漏。
ExecutorService es;
ThreadLocal tl;
es.execute(()->{
//ThreadLocal增加变量
tl.set(obj);
try{
//业务代冯
}finally{
//于动消ThreadLocal
tl.remove();}
})；

Message 的执行时刻如何管理

  • 发送的 Message 都是按照执行时刻 when 属性的先后管理在 MessageQueue 里
    延时 Message 的 when 等于调用的当前时刻和 delay 之和
    非延时 Message 的 when 等于当前时刻（delay 为 0）
  • 插队 Message 的 when 固定为 0，便于插入队列的 head之后 MessageQueue 会根据 读取的时刻和 when 进行比较将 when 已抵达的出队，尚未抵达的计算出 当前时刻和目标 when 的插值 ，交由 Native 等待对应的时长，时间到了自动唤醒继续进行 Message 的读取
  • 事实上，无论上述哪种 Message 都不能保证在其对应的 when 时刻执行，往往都会延迟一些！因为必须等当前执行的 Message 处理完了才有机会读取队列的下一个 Message。
    比如发送了非延时 Message，when 即为发送的时刻，可它们不会立即执行。都要等主线程现有的任务（Message）走完才能有机会出队，而当这些任务执行完 when 的时刻已经过了。假使队列的前面还有其他 Message 的话，延迟会更加明显！

Looper等待如何准确唤醒的？

读取合适 Message 的 MessageQueue#next() 会因为 Message 尚无或执行条件尚未满足进行两种等的等待：

  • 无限等待
    尚无 Message（队列中没有 Message 或建立了同步屏障但尚无异步 Message）的时候，调用 Natvie 侧的 pollOnce() 会传入参数 -1 。
    Linux 执行 epoll_wait() 将进入无限等待，其等待合适的 Message 插入后调用 Native 侧的 wake() 唤醒 fd 写入事件触发唤醒 MessageQueue 读取的下一次循环

  • 有限等待
    有限等待的场合将下一个 Message 剩余时长作为参数 交给 epoll_wait()，epoll 将等待一段时间之后 自动返回 ，接着回到 MessageQueue 读取的下一次循环。

Handler机制原理

  • Looper 准备和开启轮循：
    尚无 Message 的话，调用 Native 侧的 pollOnce() 进入 无限等待
    存在 Message，但执行时间 when 尚未满足的话，调用 pollOnce() 时传入剩余时长参数进入 有限等待
    Looper#prepare() 初始化线程独有的 Looper 以及 MessageQueue
    Looper#loop() 开启 死循环 读取 MessageQueue 中下一个满足执行时间的 Message

  • Message 发送、入队和出队：
    Native 侧如果处于无限等待的话：任意线程向 Handler 发送 Message 或 Runnable 后，Message 将按照 when 条件的先后，被插入 Handler 持有的 Looper 实例所对应的 MessageQueue 中 适当的位置 。MessageQueue 发现有合适的 Message 插入后将调用 Native 侧的 wake() 唤醒无限等待的线程。这将促使 MessageQueue 的读取继续 进入下一次循环 ，此刻 Queue 中已有满足条件的 Message 则出队返回给 Looper
    Native 侧如果处于有限等待的话：在等待指定时长后 epoll_wait 将返回。线程继续读取 MessageQueue，此刻因为时长条件将满足将其出队

  • handler处理 Message 的实现：
    Looper 得到 Message 后回调 Message 的 callback 属性即 Runnable，或依据 target 属性即 Handler，去执行 Handler 的回调。存在 mCallback 属性的话回调 Handler$Callback反之，回调 handleMessage()

6. 了解View绘制流程吗？

Activity启动走完onResume方法后，在ActivityThread#handleResumeActivity会进行window的添加。
window添加过程会调用 ViewRootImpl的setView() 方法，setView()方法会调用 requestLayout() 方法来请求绘制布局，requestLayout()方法内部又会走到 scheduleTraversals() 方法，最后会走到 performTraversals() 方法，接着到了我们熟知的测量、布局、绘制三大流程了。

  • 所有UI的变化都是走到 ViewRootImpl的scheduleTraversals() 方法。
    //ViewRootImpl.javavoid scheduleTraversals() {if (!mTraversalScheduled) {//此字段保证同时间多次更改只会刷新一次，例如TextView连续两次setText(),也只会走一次绘制流程mTraversalScheduled = true;//添加同步屏障，屏蔽同步消息，保证VSync到来立即执行绘制mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier();//mTraversalRunnable是TraversalRunnable实例，最终走到run()，也即doTraversal();mChoreographer.postCallback(Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);if (!mUnbufferedInputDispatch) {scheduleConsumeBatchedInput();}notifyRendererOfFramePending();pokeDrawLockIfNeeded();}}final class TraversalRunnable implements Runnable {@Overridepublic void run() {doTraversal();}}final TraversalRunnable mTraversalRunnable = new TraversalRunnable();void doTraversal() {if (mTraversalScheduled) {mTraversalScheduled = false;//移除同步屏障mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier);...//开始三大绘制流程performTraversals();...}}
  1. 首先使用mTraversalScheduled字段保证同时间多次更改只会刷新一次，例如TextView连续两次setText()，也只会走一次绘制流程。
  2. 然后把当前线程的消息队列Queue添加了同步屏障，这样就屏蔽了正常的同步消息，保证VSync到来后立即执行绘制，而不是要等前面的同步消息。后面会具体分析同步屏障和异步消息的代码逻辑。
  3. 调用了mChoreographer.postCallback()方法，发送一个会在下一帧执行的回调，即在下一个VSync到来时会执行TraversalRunnable–>doTraversal()—>performTraversals()–>绘制流程。

mChoreographer，是在ViewRootImpl的构造方法内使用Choreographer.getInstance()创建：

Choreographer mChoreographer;
//ViewRootImpl实例是在添加window时创建
public ViewRootImpl(Context context, Display display) {...mChoreographer = Choreographer.getInstance();...
}

    public static Choreographer getInstance() {return sThreadInstance.get();}private static final ThreadLocal<Choreographer> sThreadInstance =new ThreadLocal<Choreographer>() {@Overrideprotected Choreographer initialValue() {Looper looper = Looper.myLooper();if (looper == null) {//当前线程要有looper，Choreographer实例需要传入throw new IllegalStateException("The current thread must have a looper!");}Choreographer choreographer = new Choreographer(looper, VSYNC_SOURCE_APP);if (looper == Looper.getMainLooper()) {mMainInstance = choreographer;}return choreographer;}};

    private Choreographer(Looper looper, int vsyncSource) {mLooper = looper;//使用当前线程looper创建 mHandlermHandler = new FrameHandler(looper);//USE_VSYNC 4.1以上默认是true，表示 具备接受VSync的能力，这个接受能力就是FrameDisplayEventReceivermDisplayEventReceiver = USE_VSYNC? new FrameDisplayEventReceiver(looper, vsyncSource): null;mLastFrameTimeNanos = Long.MIN_VALUE;// 计算一帧的时间，Android手机屏幕是60Hz的刷新频率，就是16msmFrameIntervalNanos = (long)(1000000000 / getRefreshRate());// 创建一个链表类型CallbackQueue的数组，大小为5，//也就是数组中有五个链表，每个链表存相同类型的任务：输入、动画、遍历绘制等任务（CALLBACK_INPUT、CALLBACK_ANIMATION、CALLBACK_TRAVERSAL）mCallbackQueues = new CallbackQueue[CALLBACK_LAST + 1];for (int i = 0; i <= CALLBACK_LAST; i++) {mCallbackQueues[i] = new CallbackQueue();}// b/68769804: For low FPS experiments.setFPSDivisor(SystemProperties.getInt(ThreadedRenderer.DEBUG_FPS_DIVISOR, 1));}

安排任务—postCallback
回头看mChoreographer.postCallback(Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null)方法，注意到第一个参数是CALLBACK_TRAVERSAL，表示回调任务的类型，共有以下5种类型：

//输入事件，首先执行
public static final int CALLBACK_INPUT = 0;
//动画，第二执行
public static final int CALLBACK_ANIMATION = 1;
//插入更新的动画，第三执行
public static final int CALLBACK_INSETS_ANIMATION = 2;
//绘制，第四执行
public static final int CALLBACK_TRAVERSAL

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.rhkb.cn/news/427018.html

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

使用Docker安装 Skywalking（单机版）

使用Docker安装 Skywalking（单机版）

使用Docker安装 Skywalking&#xff08;单机版&#xff09; 文章目录 使用Docker安装 Skywalking&#xff08;单机版&#xff09;Skywalking 介绍Skywalking 安装 Skywalking 介绍 Skywalking官网 分布式系统的应用程序性能监视工具&#xff0c;专为微服务、云原生架构和基于容…
阅读更多...
水果成熟度检测系统源码分享

水果成熟度检测系统源码分享

水果成熟度检测检测系统源码分享 [一条龙教学YOLOV8标注好的数据集一键训练_70全套改进创新点发刊_Web前端展示] 1.研究背景与意义 项目参考AAAI Association for the Advancement of Artificial Intelligence 项目来源AACV Association for the Advancement of Computer V…
阅读更多...
如何准备教师资格证科目三“学科知识与教学能力”的考试与面试？（理科导向：数学/物理）

如何准备教师资格证科目三“学科知识与教学能力”的考试与面试？（理科导向：数学/物理）

如何准备教师资格证科目三“学科知识与教学能力”的考试与面试&#xff1f;&#xff08;理科导向&#xff1a;数学/物理&#xff09; ​ 目录 收起 1 前言 1.1 自身经历 1.2 教师资格证的作用 2 知识点题型分数的分布与学习建议 2.1 科目三的知识点分数分布&#xff1a; …
阅读更多...
提高数据集成稳定性：EMQX Platform 端到端规则调试指南

提高数据集成稳定性：EMQX Platform 端到端规则调试指南

自 5.7.0 版本起&#xff0c;EMQX 支持了 SQL 调试&#xff0c;并支持在数据集成全流程中进行规则调试&#xff0c;使用户能够在开发阶段就全面验证和优化规则&#xff0c;确保它们在生产环境中的稳定高效运行。 点击此处下载 EMQX 最新版本&#xff1a;https://www.emqx.com/z…
阅读更多...
【C++语言】C/C++内存管理

【C++语言】C/C++内存管理

一、C/C内存分布 我们先来看一看C/C中有哪些区域&#xff0c;为什么C/C中区分这些区域呢&#xff1f;&#xff1f;不同的数据有不同的存储需求&#xff0c;各个区域满足不同的需求。我们有临时用的数据&#xff0c;该数据是存储在栈帧区域的&#xff1b;在一些数据结构中&#…
阅读更多...
自媒体起号新思路！利用AI创作治愈类内容的运营指南

自媒体起号新思路！利用AI创作治愈类内容的运营指南

最近&#xff0c;治愈类内容在各大社交平台上备受欢迎。无论是刷短视频还是看小红书&#xff0c;都能发现这类账号的流量巨大&#xff0c;粉丝数量飞速增长。 总而言之&#xff0c;汇成一句话&#xff1a; 如何利用AI技术&#xff0c;创作治愈类的图片和视频&#xff0c;吸引粉…
阅读更多...
JavaEE:网络初识

JavaEE:网络初识

文章目录 网络初识网络中的重要概念IP地址端口号认识协议(最核心概念)OSI七层模型TCP/IP五层(或四层)网络模型网络设备所在分层封装和分用 网络初识 网络中的重要概念 网络互联的目的是进行网络通信,也是网络数据传输,更具体一点,是网络主机中的不同进程间,基于网络传输数据.…
阅读更多...
html，css基础知识点笔记（二）

html，css基础知识点笔记（二）

9.18&#xff08;二&#xff09; 本文主要教列表的样式设计 1&#xff09;文本溢出 效果图 文字限制一行显示几个字&#xff0c;多余打点 line-height: 1.8em; white-space: nowrap; width: 40em; overflow: hidden; text-overflow: ellipsis;em表示一个文字的大小单位&…
阅读更多...
计算机人工智能前沿进展-大语言模型方向-2024-09-18

计算机人工智能前沿进展-大语言模型方向-2024-09-18

计算机人工智能前沿进展-大语言模型方向-2024-09-18 1. The Application of Large Language Models in Primary Healthcare Services and the Challenges W YAN, J HU, H ZENG, M LIU, W LIANG - Chinese General Practice, 2024 人工智能大语言模型在基层医疗卫生服务中的应…
阅读更多...
【Delphi】知道控件名称（字符串），访问控件

【Delphi】知道控件名称（字符串），访问控件

在 Delphi 中&#xff0c;可以使用 RTTI&#xff08;运行时类型信息&#xff09; 或其他方法通过对象的名称字符串来访问对象。比如&#xff0c;如果你有一个控件的名称字符串&#xff0c;你希望通过该名称找到并访问实际的控件。 以下是通过 RTTI 以及其他技术&#xff08;如…
阅读更多...
SAP B1 单据页面自定义 - 用户界面编辑字段

SAP B1 单据页面自定义 - 用户界面编辑字段

背景 接《SAP B1 基础实操 - 用户定义字段 (UDF)》&#xff0c;在设置完自定义字段后&#xff0c;如下图&#xff0c;通过打开【用户定义字段】可打开表单右侧的自定义字段页。然而再开打一页附加页面操作繁复&#xff0c;若是客户常用的定义字段&#xff0c;也可以把这些用户…
阅读更多...
图片类型转化---模拟某wps

图片类型转化---模拟某wps

文件上传功能的深入探讨 文件上传是Web应用程序中常见的功能&#xff0c;它允许用户将本地文件通过Web界面发送到服务器。在Flask中&#xff0c;这通常是通过处理表单数据来实现的。表单必须设置enctype为multipart/form-data&#xff0c;这样浏览器才能将文件作为多部分消息发…
阅读更多...
GitLab CI_CD 从入门到实战笔记

GitLab CI_CD 从入门到实战笔记

第1章 认识GitLab CI/CD 1.3　GitLab CI/CD的几个基本概念 GitLab CI/CD由以下两部分构成。 &#xff08;1&#xff09;运行流水线的环境。它是由GitLab Runner提供的&#xff0c;这是一个由GitLab开发的开源软件包&#xff0c;要搭建GitLab CI/CD就必须安装它&#xff0c;因…
阅读更多...
实战分享：我是如何挖到CSDN漏洞的？

实战分享：我是如何挖到CSDN漏洞的？

文章目录 前言一、过程二、总结《Windows信息安全和网络攻防》——清华大学出版社 前言 CxxN是国内很出名的博客平台&#xff0c;用户量非常大&#xff0c;注册用户据说有1个亿&#xff1f;(官方写的)本次我发现的漏洞详情是可以通过用户的id直接获取用户完整的手机号&#xf…
阅读更多...
【深度学习】（2）--PyTorch框架认识

【深度学习】（2）--PyTorch框架认识

文章目录 PyTorch框架认识1. Tensor张量定义与特性创建方式 2. 下载数据集下载测试展现下载内容 3. 创建DataLoader&#xff08;数据加载器&#xff09;4. 选择处理器5. 神经网络模型构建模型 6. 训练数据训练集数据测试集数据 7. 提高模型学习率 总结 PyTorch框架认识 PyTorc…
阅读更多...
第二届”青春同行 共享未来“两岸新媒体创享活动在京开启

第二届”青春同行 共享未来“两岸新媒体创享活动在京开启

9月6日&#xff0c;第二届“青春同行 共享未来”两岸新媒体创享活动在北京盛大开启。本次活动旨在促进两岸青年文化交流与合作&#xff0c;共同探索新媒体时代两岸文化与经济的创新与发展新路径。爱迪斯通董事长吴明勳先生作为特邀嘉宾出席活动并发表演讲&#xff0c;在演讲中吴…
阅读更多...
RK3568部署DOCKER启动服务器失败解决办法

RK3568部署DOCKER启动服务器失败解决办法

按照上文的方法部署完DOCKER之后&#xff0c;启动服务异常&#xff0c;查阅网络相关资源&#xff0c;解决方案如下&#xff1a; 修改/源码/kernel/arch/arm64/configs/OK3568-C-linux_defconfig&#xff0c;在最后添加 CONFIG_MEMCGy CONFIG_VETHy CONFIG_BRIDGEy CONFIG_BRID…
阅读更多...
算法训练——day16快乐数

算法训练——day16快乐数

202. 快乐数 编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」 定义为&#xff1a; 对于一个正整数&#xff0c;每一次将该数替换为它每个位置上的数字的平方和。然后重复这个过程直到这个数变为 1&#xff0c;也可能是 无限循环 但始终变不到 1。如果这个过程 结果为…
阅读更多...
2024年 现象级的商业模式 上海某店！为何能火爆出圈！

2024年 现象级的商业模式 上海某店！为何能火爆出圈！

大家好&#xff0c;我是吴军&#xff0c;目前在一家备受瞩目的软件开发公司担任产品管理的重要角色。 当前&#xff0c;市场正经历着商业模式的深刻变革&#xff0c;一种创新的商业模式如潮水般涌现&#xff0c;它巧妙地为消费者编织了省钱的网络&#xff0c;同时也为商家铺设了…
阅读更多...
软考架构-面向服务的架构风格

软考架构-面向服务的架构风格

一、SOA 1、概念 面向服务开发&#xff0c;服务之间通过简单、精确定义接口进行通信&#xff0c;不涉及底层编程接口和通信模型。多个服务挂载在ESB&#xff08;企业服务总线&#xff09;上进行通信。 2、特征 可从企业外部访问、随时可用&#xff08;服务请求能被及时响应…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发