当前位置： 首页 > article >正文

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

article 2024/11/15 15:13:21

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() 进行截断
        <receiver
            android: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";
    @Override
    public 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);
        }
        @Override
        public 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() {
   
            @Override
            public void run() {
   
                handler1.sendEmptyMessage(0);
            }
        }).start();
  • 在子线程使用需要先创建Looper环境，调用Looper.prepare()，然后再创建Handler。最后在调用Looper.loop()启动消息循环。子线程Handler不使用时要调用handler.getLooper().quitSafely()退出Looper否则会阻塞。
	private static class MyHandler extends Handler {
   

	        @Override
	        public void handleMessage(@NonNull Message msg) {
   
	            super.handleMessage(msg);
	            if (msg.what == 0) {
   
	                Log.e("child thread", "receive msg from main thread");
	            }
	        }
	    }
	private Handler handler1;
   
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        
	    new Thread(new Runnable() {
   
	            @Override
	            public void run() {
   
	                Looper.prepare(); //准备Looper环境
	                handler1 = new MyHandler();
	                Looper.loop(); //启动Looper
	                Log.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 interception
        AndroidOs.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 certificates
        final 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(new
                    LogPrinter(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.java
    void 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 {
   
        @Override
        public 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>() {
   
        @Override
        protected 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创建 mHandler
        mHandler = new FrameHandler(looper);
        //USE_VSYNC 4.1以上默认是true，表示 具备接受VSync的能力，这个接受能力就是FrameDisplayEventReceiver
        mDisplayEventReceiver = USE_VSYNC
                ? new FrameDisplayEventReceiver(looper, vsyncSource)
                : null;
        mLastFrameTimeNanos = Long.MIN_VALUE;

		// 计算一帧的时间，Android手机屏幕是60Hz的刷新频率，就是16ms
        mFrameIntervalNanos = (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.kler.cn/a/310349.html

相关文章：

  • Go语言 实现将中文转化为拼音
  • java八股-jvm入门-程序计数器，堆，元空间，虚拟机栈，本地方法栈，类加载器，双亲委派，类加载执行过程
  • vivo 游戏中心包体积优化方案与实践
  • 微信小程序=》基础=》常见问题=》性能总结
  • ML 系列： 第 24 节 — 离散概率分布（泊松分布）
  • vue2或vue3的name属性有什么作用？
  • 为什么 ECB 模式不安全
  • ETL架构类型有哪些？怎么选择？
  • 力扣之1075.项目员工I
  • Java 垃圾收集器详解：CMS, G1, ZGC
  • 国产服务器CPU发展分析
  • 「数据科学」转换数据，数据存储空间和类型转换
  • spark学习笔记
  • 基于JAVA的居家办公OA系统
  • Java中的数据脱敏与隐私保护：实现GDPR与隐私安全的最佳实践
  • c#的委托、事件
  • Red Hat 和 Debian Linux 对比
  • 异常（Exception）
  • 24年蓝桥杯及攻防世界赛题-MISC-2
  • LeetCode41. 缺失的第一个正数（2024秋季每日一题 20）
  • OpenHarmony（鸿蒙南向开发）——标准系统方案之扬帆移植案例
  • Qt安卓开发连接手机调试(红米K60为例)
  • 宠物定位技术升级，蓝牙定位让爱宠随时在线
  • 《机器学习by周志华》学习笔记-神经网络-02感知机与多层网络
  • SQL 多表联查
  • DAY60Bellman_ford 算法