>> 欢迎您 客人: 登录 | 注册 | 在线 | 搜索 | 风格 | 帮助 | 统计 | 文章 返回首页
>>分享Android开发相关的技术 书籍支持  卫琴直播  品书摘要  在线测试  资源下载  联系我们
Java技术网站 → 『 Java开发技术 』 → 『 Android技术专题 』 → Android性能优化：App启动原理分析及启动时间优化
发表一个新主题 开启一个新投票 回复文章 您是本文章第 19724 个阅读者 刷新本主题
 * 贴子主题:  Android性能优化：App启动原理分析及启动时间优化 回复文章 点赞(0)  收藏  
作者:Jacky    发表时间：2020-03-08 23:19:36     消息  查看  搜索  好友  邮件  复制  引用
                                                                                                

Android性能优化（一）App启动原理分析及启动时间优化

一、启动原理解析

  Android是基于Linux内核的，当手机启动，加载完Linux内核后，会由Linux系统的init祖先进程fork出Zygote进程，所有的Android应用程序进程以及系统服务进程都是这个Zygote的子进程（由它fork出来的）。其中最重要的一个就是SystemServer，在ZygoteInit类的main方法中，会调用startSystemServer方法开启系统里面重要的服务，包括ActivityManagerService（Activity管理器，简称AMS，可以理解为一个服务进程，负责Activity的生命周期管理）、PackageManagerService（包管理器）、WindowManagerService（窗口管理器）、PowerManagerService（电量管理器）等等，这个过程中还会创建系统上下文。                  

  1.       public  final   class  SystemServer {
  3.           //zygote的主入口
  4.            public  static  void  main (String[] args) {
  5.               new SystemServer().run();
  6.          }
  8.            public  SystemServer () {
  9.               // Check for factory test mode.
  10.              mFactoryTestMode = FactoryTest.getMode();
  11.          }
  13.            private  void  run () {
  15.              ...ignore some code...
  17.               //加载本地系统服务库，并进行初始化
  18.              System.loadLibrary( "android_servers");
  19.              nativeInit();
  21.               // 创建系统上下文
  22.              createSystemContext();
  24.               //初始化SystemServiceManager对象，下面的系统服务开启都需要调用SystemServiceManager.startService(Class<T>)，这个方法通过反射来启动对应的服务
  25.              mSystemServiceManager =  new SystemServiceManager(mSystemContext);
  27.               //开启服务
  28.               try {
  29.                  startBootstrapServices();
  30.                  startCoreServices();
  31.                  startOtherServices();
  32.              }  catch (Throwable ex) {
  33.                  Slog.e( "System",  "******************************************");
  34.                  Slog.e( "System",  "************ Failure starting system services", ex);
  35.                   throw ex;
  36.              }
  38.              ...ignore some code...
  40.          }
  42.           //初始化系统上下文对象mSystemContext，并设置默认的主题,mSystemContext实际上是一个ContextImpl对象。调用ActivityThread.systemMain()的时候，会调用ActivityThread.attach(true)，而在attach()里面，则创建了Application对象，并调用了Application.onCreate()。
  43.            private  void  createSystemContext () {
  44.              ActivityThread activityThread = ActivityThread.systemMain();
  45.              mSystemContext = activityThread.getSystemContext();
  46.              mSystemContext.setTheme(android.R.style.Theme_DeviceDefault_Light_DarkActionBar);
  47.          }
  49.           //在这里开启了几个核心的服务，因为这些服务之间相互依赖，所以都放在了这个方法里面。
  50.            private  void  startBootstrapServices () {
  52.              ...ignore some code...
  54.               //初始化ActivityManagerService
  55.              mActivityManagerService = mSystemServiceManager.startService(
  56.                      ActivityManagerService.Lifecycle.class).getService();
  57.              mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
  59.               //初始化PowerManagerService，因为其他服务需要依赖这个Service，因此需要尽快的初始化
  60.              mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);
  62.               // 现在电源管理已经开启，ActivityManagerService负责电源管理功能
  63.              mActivityManagerService.initPowerManagement();
  65.               // 初始化DisplayManagerService
  66.              mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);
  68.           //初始化PackageManagerService
  69.          mPackageManagerService = PackageManagerService.main(mSystemContext, mInstaller,
  70.             mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF, mOnlyCore);
  72.          ...ignore some code...
  74.          }
  76.      }

       注意一个很重要的地方    

  1.         private  void  createSystemContext () {
  2.              ActivityThread activityThread = ActivityThread.systemMain();
  3.              mSystemContext = activityThread.getSystemContext();
  4.                        mSystemContext.setTheme(android.R.style.Theme_DeviceDefault_Light_DarkActionBar);
  5.          }

   这里干了三件事，一个是创建ActivityThread，这个ActivityThread就是我们常说的“主线程”,也就是所谓的UI线程，APP的主入口。ActivityThread随后会创建一个mainLooper来开启消息循环，这也就是为什么在"主线程"中我们使用Handler不需要手动创建Looper的原因。第二件事是获得了系统的上下文，第三件事是设置了默认的主题。如果想要启动新的应用，ActivityManagerService会通过socket进程间通信（IPC）机制来通知Zygote进程fork出新的进程。                      

二、当我们点击了一个APP图标时发生了什么

     系统第一个启动的APP是Lancher，也就是我们手机的主界面，继承自Activity，实现了点击事件、触摸、长按等接口，在android源码Lancher.java中，我们可以看到onclick方法    

  1.        public  void  onClick (View v) {
  3.                ...ignore some code...
  5.               Object tag = v.getTag();
  6.               if (tag  instanceof ShortcutInfo) {
  7.                   // Open shortcut
  8.                   final Intent intent = ((ShortcutInfo) tag).intent;
  9.                   int[] pos =  new  int[ 2];
  10.                  v.getLocationOnScreen(pos);
  11.                  intent.setSourceBounds( new Rect(pos[ 0], pos[ 1],
  12.                          pos[ 0] + v.getWidth(), pos[ 1] + v.getHeight()));
  13.               //开始开启Activity
  14.                   boolean success = startActivitySafely(v, intent, tag);
  16.                   if (success && v  instanceof BubbleTextView) {
  17.                      mWaitingForResume = (BubbleTextView) v;
  18.                      mWaitingForResume.setStayPressed( true);
  19.                  }
  20.              }  else  if (tag  instanceof FolderInfo) {
  21.                   //如果点击的是图标文件夹，就打开文件夹
  22.                   if (v  instanceof FolderIcon) {
  23.                      FolderIcon fi = (FolderIcon) v;
  24.                      handleFolderClick(fi);
  25.                  }
  26.              }  else  if (v == mAllAppsButton) {
  27.              ...ignore some code...
  28.              }
  29.          }

    可以看出我们点击了主界面上的应用图标后调用的就是startActivitySafely这个方法，继续深入进去，然后再往下走，我们发现调用的是startActivity方法，最后会调用   Instrumentation.   execStartActivity()， Instrumentation   这个类就是完成对Application和Activity初始化和生命周期的工具类，然后 Instrumentation会通过ActivityManagerService的远程接口向AMS发消息，让他启动一个Activity。  也就是说 调用startActivity(Intent)以后,
会通过Binder IPC机制, 最终调用到ActivityManagerService。AMS 会通过socket通道传递参数给Zygote进程。Zygote孵化自身, 并调用ZygoteInit.main()方法来实例化ActivityThread对象并最终返回新进程的pid。 ActivityThread随后依次调用Looper.prepareLoop()和Looper.loop()来开启消息循环。在 ActivityThread会创建并绑定Application，这个时候才会 realStartActivity()，并且AMS会将生成的Activity加到ActivityTask的栈顶，并通知ActivityThread暂停当前Activity（暂停Lancher，进入我们自己的APP）。

               点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小    

     三、Application在何处初始化

      在 ActivityThread.main()中，有一句话是thread.attach(false)，在这个attach方法中，有一句比较重要的地方                    

mgr.attachApplication(mAppThread)

    这个就会通过Binder调用到AMS里面对应的方法,继续研究源码，在handleBindApplication中，完成了Application的创建
在makeApplication方法中，最后调用的是instrumentation.callApplicationOnCreate(app);
这个方法里面的onCreate就是调用了我们Application的OnCreate方法。            

  1.        public Application  makeApplication  ( boolean forceDefaultAppClass,
  2.                   Instrumentation instrumentation) {
  3.               if (mApplication !=  null) {
  4.                   return mApplication;
  5.              }
  7.              Application app =  null;
  9.              String appClass = mApplicationInfo.className;
  10.               if (forceDefaultAppClass || (appClass ==  null)) {
  11.                  appClass =  "android.app.Application";
  12.              }
  14.               try {
  15.                  java.lang.ClassLoader cl = getClassLoader();
  16.                   if (!mPackageName.equals( "android")) {
  17.                      initializeJavaContextClassLoader();
  18.                  }
  19.                  ContextImpl appContext = ContextImpl.createAppContext(mActivityThread,  this);
  20.                  app = mActivityThread.mInstrumentation.newApplication(
  21.                          cl, appClass, appContext);
  22.                  appContext.setOuterContext(app);
  23.              }  catch (Exception e) {        }
  24.              mActivityThread.mAllApplications.add(app);
  25.              mApplication = app;
  27.           //传进来的是null，所以这里不会执行，onCreate在上一层执行
  28.               if (instrumentation !=  null) {
  29.                   try {
  30.                      instrumentation.callApplicationOnCreate(app);
  31.                  }  catch (Exception e) {
  33.                  }
  34.              }
  35.              ...ignore some code...
  37.             }
  39.               return app;
  40.          }

   上面的三点，用一张图来改概括，就是
        
点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

      四、什么地方我们可以进行优化

       首先需要明确的是，在Application的onCreate之前，这个时间都是无法进行优化的，因为这部分是系统替我们完成的，开发者无能为力。所以我们能做的，就是从 Application的onCreate方法开始，到lauyout_main.xml第一次布局绘制完成之前，来进行启动时间的优化。          

       五、冷启动与热启动的区别

        1 冷启动：当启动应用时，后台没有该应用的进程，这时系统会重新创建一个新的进程分配给该应用，这个启动方式就是冷启动。冷启动因为系统会重新创建一个新的进程分配给它，所以会先创建和初始化
Application 类，再创建和初始化 MainActivity 类，最后显示在界面上。

        2  热启动：当启动应用时，后台已有该应用的进程（例：按back键、home键，应用虽然会退出，但是该应用的进程是依然会保留在后台，可进入任务列表查看），所以在已有进程的情况下，这种启动会从已有的进程中来启动应用，这个方式叫热启动。热启动因为会从已有的进程中来启动，所以热启动就不会走 Application 这步了，而是直接走 MainActivity，所以热启动的过程不必创建和初始化 Application，因为一个应用从新进程的创建到进程的销毁，Application 只会初始化一次。              

       六、时间定义

        由于冷启动过程中，系统和APP的许多工作都要重新开始，所以一般而言这种启动方式是最慢且最具有挑战性的。除了创建和初始化Application和MainActivity之外，冷启动还要加载主题样式Theme， inflate布局，setContentView
，测量、布局、绘制以后显示，我们才看到了屏幕的第一帧。
  
              1.DisplayTime
       API19以后，Android在系统Log中增加了Display的Log信息， 在Android Studio中运行我们的App后，我们可以在Logcat中过滤ActivityManager以及Display这两个关键字，可以看到
        点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

      这个 DisplayTime的Log 信息在activity
窗口完成所有的启动事件之后，第一次绘制的时候输出。  这个时间包括了从Activity启动到Layout全部显示的过程 。这基本上就是你需要优化的主要时间。它不包含用户点击app图标然后系统开始准备启动activity的时间，因为作为一个开发者你无法影响这个时间，所以没有必要去测量它。

                    2.reportFullyDrawn
    

   系统日志中的Display Time只是布局的显示时间，并不包括数据的加载，因为很多App在加载时会使用懒加载模式，即数据拉取后，再刷新默认的UI。所以，系统给我们定义了一个类似的『自定义上报时间』——reportFullyDrawn。

  如下图:
点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

  3.三个time

  在cmd中输入 adb shell am start -W [包名]/[全类名]，即通过adb启动我们的Activity或Service，控制台也会输出我们的启动时间

     点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

   此法获取的启动时间非常精准，可精确到毫秒。那么这三个Thistime,TotalTime,WaitTime分别代表什么呢？    
  •    ThisTime: 最后一个启动的Activity的启动耗时
  •    自己的所有Activity的启动耗时
  •    WaitTime: ActivityManagerService启动App的Activity时的总时间（包括当前Activity的onPause()和自己Activity的启动）
        这三个时间不是很好理解，我们可以把整个过程分解

    1.上一个Activity的onPause()——2.系统调用AMS耗时——3.第一个Activity（也许是闪屏页）启动耗时——4.第一个Activity的onPause()耗时——5.第二个Activity启动耗时
        
    那么，ThisTime表示5（最后一个Activity的启动耗时）。TotalTime表示3.4.5总共的耗时（如果启动时只有一个Activity，那么ThisTime与TotalTime就是一样的）。WaitTime则表示所有的操作耗时，即1.2.3.4.5所有的耗时。

     如果还是没有理解，可以查看framework层ActivityRecord源码，其中有这几个time的计算方法，
    最关键的几行代码        

  1.         public  void  reportFullyDrawnLocked () {
  2.               final  long curTime = SystemClock.uptimeMillis();
  3.               if (displayStartTime !=  0) {
  4.                  reportLaunchTimeLocked(curTime);
  5.              }
  6.               final ActivityStack stack = task.stack;
  7.               if (fullyDrawnStartTime !=  0 && stack !=  null) {
  8.                   final  long thisTime = curTime - fullyDrawnStartTime;
  9.                   final  long totalTime = stack.mFullyDrawnStartTime !=  0
  10.                          ? (curTime - stack.mFullyDrawnStartTime) : thisTime;
  11.      }

   逻辑如下图
      
点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

       七、为什么启动时会出现短暂黑屏或白屏的现象

        系统进程在创建Application的过程中会产生一个BackgroudWindow，等到App完成了第一次绘制，系统进程才会用MainActivity的界面替换掉原来的 BackgroudWindow，见下图
        
             点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小
         也就是说当用户点击你的app那一刻到系统调用Activity.onCreate()之间的这个时间段内，WindowManager会先加载app主题样式中的windowBackground做为app的预览元素，然后再真正去加载activity的layout布局。

         很显然，如果你的application或activity启动的过程太慢，导致系统的BackgroundWindow没有及时被替换，就会出现启动时白屏或黑屏的情况（取决于你的主题是Dark还是Light）。

         八、冷启动优化

         1.主题替换
         我们在style中自定义一个样式Lancher，在其中放一张背景图片，或是广告图片之类的                          

  1.      <style name= "AppTheme.Launcher">
  2.              <item name= "android:windowBackground"> @drawable/bg</item>
  3.          </style>

  把这个样式设置给启动的Activity

  1.       < activity
  2.                   android:name= ".activity.SplashActivity"
  3.                   android:screenOrientation= "portrait"
  4.                   android:theme= "@style/AppTheme.Launcher"
  5.                  >

  然后在Activity的onCreate方法，把Activity设置回原来的主题                  

  1.      @Override
  2.          protected void onCreate(Bundle savedInstanceState) {
  3.              //替换为原来的主题，在onCreate之前调用
  4.              setTheme(R.style.AppTheme);
  5.              super.onCreate(savedInstanceState);
  6.          }

   这样在启动时就通过给用户看一张图片或是广告来防止黑白屏的尴尬。

                          还一种方式，就是把windowBackground属性设为null，这样在启动时，backgroundWindow的背景就会变成透明的，给人的感觉就是点了应用图标以后，延迟了一会儿然后加载第一个activity的界面。          

  1.       < style  name= "AppTheme.Launcher">
  2.               < item  name= "android:windowBackground">@null </ item>
  3.           </ style>

           2.优化Application和MainActivity
        
             上面所说的改变主题实际上是一种伪优化，因为它实质上并没有真正减少App启动的时间。
        
             Application是程序的主入口，特别是很多第三方SDK都会需要在Application的onCreate里面做很多初始化操作，不得不说，各种第三方SDK，都特别喜欢这个『兵家必争之地』，再加上自己的一些库的初始化，会让整个Application不堪重负。 优化的方法，无非是通过以下几个方面：
  •   延迟初始化
  •   后台任务
  •   界面预加载
                      在Application的构造器方法、attachBaseContext()、onCreate()方法中不要进行耗时操作的初始化，一些数据预取放在异步线程中。

             数据库，IO操作，密集网络请求不要放在Application的构造方法中，能使用工作线程的尽量使用工作线程，不要在Application的onCreate中创建线程池，因为那样会有比较大的开销，可以考虑延后再创建。
            第三方SDK如果主线程中没有立即使用，可以考虑延迟几秒再初始化，总之一句话，尽早让用户看到应用的界面，其他操作都可以先让路。
        
            对于MainActivity，由于在获取到第一帧前，需要对contentView进行测量布局绘制操作，尽量减少布局的层次，考虑StubView的延迟加载策略，当然在onCreate、onStart、onResume方法中避免做耗时操作。

            对于sharedPreferences的初始化，因为 sharedPreferences的特性在初始化时候会对数据全部读出来存在内存中，所以这个初始化放在主线程中不合适，反而会延迟应用的启动速度，对于这个还是需要放在异步线程中处理。

            例子          

  1.       new Thread(){
  2.                   @Override
  3.                    public  void  run () {
  4.                      initNim();
  5.                      initImagePicker();
  6.                      initOkHttp();
  7.                  }
  8.              }.start();

         九、优化启动时间的一个很好用的工具
TraceView

      TraceView 是 Android SDK 中内置的一个工具，它可以加载
trace 文件，用图形的形式展示代码的执行时间、次数及调用栈，便于我们分析。

      用法很简单，在你想要测试花费时间的代码之前，调用Debug.startMethodTracing(filename)， 系统会生产
trace 文件，并且产生追踪数据，在结束处调用代码 Debug.stopMethodTracing()时，会将追踪数据写入到 trace 文件中。以下代码在sd卡中生成trace文件                      

  1.      File file =  new File(Environment.getExternalStorageDirectory(),  "app7");
  2.             Log.i(TAG,  "onCreate: " + file.getAbsolutePath());
  3.             Debug.startMethodTracing(file.getAbsolutePath());
  4.               //对全局属性赋值
  5.              mContext = getApplicationContext();
  6.              mMainThread = Thread.currentThread();
  7.              mMainThreadId = android.os.Process.myTid();
  8.              mMainLooper = getMainLooper();
  9.              mHandler =  new Handler();
  10.              initNim();
  11.              initImagePicker();
  12.              initOkHttp();
  13.              Debug.stopMethodTracing();

  如果你用的是模拟器，就可以使用下面的控制台命令将trace文件拉出到桌面上      

  1.      cd Desktop
  2.      adb pull /storage/sdcard/app7.trace

  然后将这个trace文件拖入android studio 就可以了，可以看到这样的界面
    
    点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

      具体各个部分的信息如下
         点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小
  从上半部分可以清晰的看出方法之间的调用关系和运行时间，从下半部分可以具体看出那几个方法耗时较长
  点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

  有了这样方便的工具，启动优化时对症下药就很方便了
  
  
                                                                                                      
----------------------------
原文链接:https://blog.csdn.net/SakuraMashiro/article/details/78986167

程序猿的技术大观园：www.javathinker.net



[这个贴子最后由 flybird 在 2020-03-08 23:19:36 重新编辑]
Java精品书籍推荐
Java最新视频教程推荐
  Java面向对象编程-->Lambda表达式
  JavaWeb开发-->Servlet技术详解（Ⅱ）
  JSP与Hibernate开发-->JPA API的高级用法
  Java网络编程-->创建非阻塞的HTTP服务器
  精通Spring-->Vue组件开发基础
  Vue3开发-->组合（Composition）API
本站其他相关文章
  android webView js方法和java 方法交互-android,unity3d
  Android在SDcard建文件夹（在Android中移动文件必用）
  Android UI学习 - Tab的学习和使用
  Android ExpandableListView 使用范例
  Android 滚动Tab
  众多Android 开源项目推荐
  Android 抽屉导航
  Android平台概述
  Android中的Intent Filter与安全
  Android SDCard Mount 流程分析
  UI渲染优化
  程序员笔记|JSBridge框架解决通信问题实现移动端跨平台开发
  Android中shape的使用-Kofi
  【Android 修炼手册】Gradle 篇 -- Gradle 的基本使用
  Android中竖着的Tablayout的简单使用
  更多...
 IPIP: 已设置保密
楼主      
共1页 0条记录 当前第1页
发表一个新主题 开启一个新投票 回复文章

中文版权所有： JavaThinker技术网站 Copyright 2016-2026 沪ICP备16029593号-2
荟萃Java程序员智慧的结晶，分享交流Java前沿技术。  联系我们
如有技术文章涉及侵权，请与本站管理员联系。