应用启动优化—App Startup

最新推荐文章于 2024-07-27 21:51:59 发布
最新推荐文章于 2024-07-27 21:51:59 发布
阅读量2.4k 收藏 2
点赞数 1
分类专栏： Android 文章标签： 启动优化 jetpack App Startup
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ecjtuhq/article/details/107851773
版权

一、简介

App Startup 是 Android Jetpack 家族的成员，提供了一种在应用程序启动时，简单、高效的初始化组件的方法。无论是App开发人员，还是Library开发人员都可以使用App Startup来简化启动过程，并显式地设置初始化顺序。

App Startup 不需要为每个组件的初始化定义单独的 ContentProvider，它提供了一个 ContentProvider 来运行所有依赖项的初始化，从而显著的提高了应用程序的启动速度。

 

二、已知手段

  1. 在 Application 中做初始化：利用异步延迟初始化，或者延迟到 Activity 中初始化。
  2. 在 ContentProvider 中做初始化：在 Application 的 onCreate 方法之前执行。
  3. 阿里巴巴开源的 Alpha：基于PERT图构建的异步启动框架。
  4. 自定义启动器 做初始化：基于有向无环图拓扑排序的启动框架。

 

三、如何使用

1. 添加依赖

implementation "androidx.startup:startup-runtime:1.0.0-alpha02"

2. 实现Initializer<T>接口

public class Sdk4Initializer implements Initializer<Sdk4> {

    @NonNull
    @Override
    public Sdk4 create(@NonNull Context context) {
        // 执行初始化逻辑
        Sdk4.getInstance().init(context);
        return Sdk4.getInstance();
    }

    @NonNull
    @Override
    public List<Class<? extends Initializer<?>>> dependencies() {
        List<Class<? extends Initializer<?>>> dependencies = new ArrayList<>();
        // 添加初始化依赖项
        dependencies.add(Sdk1Initializer.class);
        dependencies.add(Sdk2Initializer.class);
        return dependencies;
    }
}

3. 注册AndroidManifest配置

<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">
    <meta-data
        android:name="com.example.demo.appstartup.Sdk1Initializer"
        android:value="@string/androidx_startup" />
    <meta-data
        android:name="com.example.demo.appstartup.Sdk3Initializer"
        android:value="@string/androidx_startup"
        tools:node="remove" />
    <meta-data
        android:name="com.example.demo.appstartup.Sdk5Initializer"
        android:value="@string/androidx_startup"
        tools:node="remove" />
</provider>
  • tools:node="merge"

在没有冲突的情况下，使用合并冲突启发式算法，合并此标记中的所有属性以及所有嵌套元素。它是节点合并的默认模式。

  • tools:node="remove"

从合并后的清单中移除此元素。此标记在provider标签下，将禁用所有组件初始化；在meta-data标签下，将禁用单个组件初始化。

  • android:value="xxx"

这里必须指定为字符串androidx_startup的值，否则声明的组件不生效。

4. 延迟初始化

<meta-data
    android:name="com.example.demo.appstartup.Sdk5Initializer"
    android:value="@string/androidx_startup"
    tools:node="remove" />

// 手动执行初始化逻辑
AppInitializer.getInstance(getApplicationContext()).initializeComponent(Sdk5Initializer.class);

 

规律：

a. 不声明meta-data标签，自动初始化失效，手动初始化依然可以生效

b. 声明meta-data标签，且添加了tools:node="remove"，自动初始化失效，手动初始化依然可以生效

c. 不声明meta-data标签，自动初始化失效；若做为依赖项，其他组件初始化之前，初始化依然可以生效

d. 声明meta-data标签，且添加了tools:node="remove"；若做为依赖项，其他组件初始化之前，初始化依然可以生效

 

四、原理简析

1. 代码结构

2. 设计思路

  • 使用 InitializationProvider 管理多个初始化项，避免创建多个 ContentProvider 做初始化，减少初始化耗时，提升 APP 的启动速度
  • 通过实现 Initializer<T> 接口，设置初始化的依赖项，自定义组件间的初始化顺序
  • 通过 Android tools 命名空间，配置组件是否自动初始化
  • 支持延迟初始化，即手动初始化

3. 核心类

1) Initializer

public interface Initializer<T> {

    /**
     * 初始化
     */
    @NonNull
    T create(@NonNull Context context);

    /**
     * 设置依赖项，用于初始化顺序
     */
    @NonNull
    List<Class<? extends Initializer<?>>> dependencies();
}

2) InitializationProvider

public final class InitializationProvider extends ContentProvider {

    /**
     * 扫描和初始化AndroidManifest中配置的组件
     */
    @Override
    public boolean onCreate() {
        Context context = getContext();
        if (context != null) {
            AppInitializer.getInstance(context).discoverAndInitialize();
        } else {
            throw new StartupException("Context cannot be null");
        }
        return true;
    }

    ...
}

3) AppInitializer

public final class AppInitializer {

    private static final String SECTION_NAME = "Startup";

    private static volatile AppInitializer sInstance;

    private static final Object sLock = new Object();

    // 缓存已经初始化过的组件信息
    @NonNull
    final Map<Class<?>, Object> mInitialized;

    @NonNull
    final Context mContext;

    AppInitializer(@NonNull Context context) {
        mContext = context.getApplicationContext();
        mInitialized = new HashMap<>();
    }

    @NonNull
    @SuppressWarnings("UnusedReturnValue")
    public static AppInitializer getInstance(@NonNull Context context) {
        if (sInstance == null) {
            synchronized (sLock) {
                if (sInstance == null) {
                    sInstance = new AppInitializer(context);
                }
            }
        }
        return sInstance;
    }

    /**
     * 用于延迟初始化(手动初始化)指定的组件
     */
    @NonNull
    @SuppressWarnings("unused")
    public <T> T initializeComponent(@NonNull Class<? extends Initializer<T>> component) {
        return doInitialize(component, new HashSet<Class<?>>());
    }

    @NonNull
    @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"})
    <T> T doInitialize(@NonNull Class<? extends Initializer<?>> component, @NonNull Set<Class<?>> initializing) {
        synchronized (sLock) {
            boolean isTracingEnabled = Trace.isEnabled();
            try {
                if (isTracingEnabled) {
                    Trace.beginSection(component.getSimpleName());
                }

                // initializing存储正在初始化的组件，这里为了处理循环依赖问题
                if (initializing.contains(component)) {
                    String message = String.format("Cannot initialize %s. Cycle detected.", component.getName());
                    throw new IllegalStateException(message);
                }
                Object result;

                // 避免重复初始化
                if (!mInitialized.containsKey(component)) {
                    initializing.add(component);
                    try {
                        // 构造一个组件的实例
                        Object instance = component.getDeclaredConstructor().newInstance();
                        Initializer<?> initializer = (Initializer<?>) instance;

                        // 读取组件的依赖项，如果有依赖项，则先逐一对依赖项做初始化
                        List<Class<? extends Initializer<?>>> dependencies = initializer.dependencies();
                        if (!dependencies.isEmpty()) {
                            for (Class<? extends Initializer<?>> clazz : dependencies) {
                                if (!mInitialized.containsKey(clazz)) {
                                    doInitialize(clazz, initializing);
                                }
                            }
                        }
                        if (StartupLogger.DEBUG) {
                            StartupLogger.i(String.format("Initializing %s", component.getName()));
                        }

                        // 调用组件的create方法，执行具体的初始化逻辑
                        result = initializer.create(mContext);
                        if (StartupLogger.DEBUG) {
                            StartupLogger.i(String.format("Initialized %s", component.getName()));
                        }

                        // 更改组件的初始化状态，并缓存结果
                        initializing.remove(component);
                        mInitialized.put(component, result);
                    } catch (Throwable throwable) {
                        throw new StartupException(throwable);
                    }
                } else {
                    result = mInitialized.get(component);
                }
                return (T) result;
            } finally {
                Trace.endSection();
            }
        }
    }

    /**
     * 用于自动初始化
     */
    @SuppressWarnings("unchecked")
    void discoverAndInitialize() {
        try {
            Trace.beginSection(SECTION_NAME);

            // 读取AndroidManifest文件, 获取InitializationProvider对应的meta-data标签信息
            ComponentName provider = new ComponentName(mContext.getPackageName(), InitializationProvider.class.getName());
            ProviderInfo providerInfo = mContext.getPackageManager().getProviderInfo(provider, GET_META_DATA);
            Bundle metadata = providerInfo.metaData;
            
            // 获取androidx_startup字符串值
            String startup = mContext.getString(R.string.androidx_startup);

            // 遍历meta-data标签信息，获取Initializer实现类信息，然后进行初始化
            if (metadata != null) {
                Set<Class<?>> initializing = new HashSet<>();
                Set<String> keys = metadata.keySet();
                for (String key : keys) {
                    String value = metadata.getString(key, null);

                    // value属性的值与字符串androidx_startup的值对比，相同才进行初始化
                    if (startup.equals(value)) {
                        // 反射获取组件信息，进行初始化
                        Class<?> clazz = Class.forName(key);
                        if (Initializer.class.isAssignableFrom(clazz)) {
                            Class<? extends Initializer<?>> component = (Class<? extends Initializer<?>>) clazz;
                            if (StartupLogger.DEBUG) {
                                StartupLogger.i(String.format("Discovered %s", key));
                            }
                            doInitialize(component, initializing);
                        }
                    }
                }
            }
        } catch (PackageManager.NameNotFoundException | ClassNotFoundException exception) {
            throw new StartupException(exception);
        } finally {
            Trace.endSection();
        }
    }
}

 

参考：

https://developer.android.google.cn/topic/libraries/app-startup

https://www.jianshu.com/p/f0902a219951

一杯苦芥
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 应用多角度启动优化
zhuxingchong的博客
06-03 1268
一、简介 1.1、冷启动和热启动 冷启动：当启动应用时，后台没有该应用的进程，这时系统会重新创建一个新的进程分配给该应用，然后再根据启动的参数，启动对应的进程组件，这个启动方式就是冷启动 热启动：当启动应用时，后台已有该应用的进程（例：按back键、home键，应用虽然会退出，但是该应用的进程是依然会保留在后台，可进入任务列表查看），所以在已有进程的情况下，这种启动会从已有的进程中来启动对应的进程组件，这个方式叫热启动 1.2、启动速度测量 1.2.1、TraceCompat TraceCo...
react-app-startup:React应用程序的启动模板
05-12
React应用程序的启动模板，如"react-app-startup"，是为初学者和开发者提供的一套预配置的项目结构，用于快速搭建基于React的Web应用。这个模板通常包含了所有必要的依赖和配置，使得开发者能够立即开始编写代码，而...
Android Jetpack组件之App Startup，2024年最新头条面试android
2401_84160041的博客
04-11 849
【Android 详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然 Android 没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪资真的特别高（钱多也不一定能找到合适的），所以努力让自己成为高级工程师才是最重要的。
HarmonyOS Next开发学习手册——应用启动框架AppStartup
maniuT的博客
06-24 1212
AppStartup提供了一种简单高效的初始化组件的方式，开发者可以使用AppStartup来显示的设置组件的初始化顺序以及之间的依赖关系，支持异步初始化组件加速应用的启动时间。开发者需要分别为待初始化的组件实现AppStartup提供的 StartupTask 接口，并在 startup_config.json 中配置AppStartup之间的依赖关系，每个StartupTask都是一个等待执行的启动任务，启动框架将使用拓扑排序保证各个启动任务的执行顺序。说明启动框架只支持在entry中使用。
android app启动时间优化,优化APP启动时间
weixin_33335851的博客
05-29 381
8种机械键盘轴体对比本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？用户希望APP可以快速响应并启动。如果APP启动较慢，则严重影响用户体验，甚至导致用户流失。本文将讲述如何优化APP启动时间。本文首先阐述APP启动过程；然后讨论如何诊断APP启动性能问题；最后m描述一些常见的APP启动时间过慢的问题，并提出一些解决方法。APP启动的内部原理APP启动有3种启动方式：cold start...
Android 性能优化——APP启动优化
小旭的专栏
03-18 2353
自定义控件和UI部件，不管这些控件是否支持 xml 化，实现它们的代码质量很重要，要尽可能简化它们的构造过程。
Jetpack 的 App Startup
彬_小彬的博客
07-27 793
App Startup 是 Jetpack 库的一部分，旨在为应用提供一个统一的、简单的初始化框架。使用这个库，开发者可以轻松地定义和管理启动时的初始化任务，并确保这些任务按照正确的顺序执行。
学习Android启动初始化 App StartUp
yuantian_shenhai的博客
09-04 1837
StartUp是为了App的启动提供的一套简单、高效的初始化方案。
Android app启动时间优化
彬_小彬的博客
07-27 566
优化 Android 应用的启动时间是提升用户体验的重要环节。应用的启动时间通常分为冷启动（应用首次启动）和热启动（应用从后台恢复）。
APP启动优化
Z1591090的博客
07-15 886
APP启动是从哪里开始的？ 有人说是从main函数开始的，因为main函数是程序的代理AppDelegate的创建入口，自然也是整个应用的入口，其实从宏观角度上来说是这样的，但认真起来却不是这样的 首先创建一个工程，然后在ViewController.m 中添加一个方法。 + (void)load { NSLog(@"load"); } 然后再main函数的地方，也就是main.m中，顺便也加一个NSLog: int main(int argc, char * argv[]) { NSS
Jetpack学习之 App Startup
2401_84408378的博客
05-05 899
这样就会出现一个问题，你两个清单文件都使用到了含有同一个 name 的标签，那么打包编译时肯定会出现问题，因为最终编译出来的 activity 的标签要是唯一的，这个地方就不知道使用哪一个。只要是程序员，不管是Java还是Android，如果不去阅读源码，只看API文档，那就只是停留于皮毛，这对我们知识体系的建立和完备以及实战技术的提升都是不利的。只要是程序员，不管是Java还是Android，如果不去阅读源码，只看API文档，那就只是停留于皮毛，这对我们知识体系的建立和完备以及实战技术的提升都是不利的。
WWDC session 406_optimizing_app_startup_time.pdf
11-08
在本次WWDC（Worldwide Developers Conference）演讲中，主题为“优化应用启动时间”（Optimizing App Startup Time），由Nick Kledzik（Dyld架构师）和Louis Gerbarg（Dyld愿景家）共同讲解。演讲主要面向那些关心...
Startup-Ki-Duniya-Website:启动ki Duniya门户的前端网站
04-16
Create React App入门 该项目是通过引导的。 可用脚本 在项目目录中，可以运行： yarn start 在开发模式下运行应用程序。 打开在浏览器中查看它。 如果您进行编辑，则页面将重新加载。 您还将在控制台中看到任何...
runoncesetup.rar_启动项
09-22
这些启动项可以在用户登录之前或之后运行，通常用于确保某些必要的服务或应用程序在电脑开启后立即可用。"runoncesetup.rar_启动项"这个压缩包文件，可能包含了实现特定启动项功能的资源。 描述中提到的"实现在显示...
开机自启设置（software-startup）.zip
09-29
通过这种方式，用户可以将这个批处理文件放在启动目录下，如Windows的 "C:\Users\用户名\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup" 目录，这样电脑开机后，这些命令就会自动执行，启动相应的...
mpu6050陀螺仪使用方法开发教程文档.docx
最新发布
07-30
mpu6050陀螺仪使用方法
【SCI顶级】龙格库塔算法RUN-CNN-LSTM-Multihead-Attention温度预测【含源码 5747期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Mutilhead-Attention回归预测
大模型的数学之魂：统计学习理论精要
07-30
大型机器学习模型，通常简称为“大模型”，是指具有数十亿甚至数千亿参数的深度神经网络模型。这些模型因为其庞大的参数量和复杂的计算结构，能够处理非常复杂的任务和数据，展现出强大的表达能力和预测性能。大模型在自然语言处理、计算机视觉、语音识别和推荐系统等多个领域都有广泛的应用。 大模型的设计目的是通过训练海量数据来学习复杂的模式和特征，从而具备强大的泛化能力，能够对未见过的数据做出准确的预测。与参数较少、层数较浅的小模型相比，大模型虽然需要更多的计算资源和时间来训练和推理，但它们展现出了一种被称为“涌现能力”的特性，即从原始训练数据中自动学习并发现新的、更高层次的特征和模式。 大模型的发展历程可以分为几个阶段，从早期的卷积神经网络模型发展到以Transformer为代表的全新神经网络模型，再到当前以GPT为代表的预训练大模型阶段。Transformer架构因其自注意力机制而成为大模型的核心技术，它使得模型能够更好地理解和处理文本数据中的长距离依赖关系。 大模型的分类主要包括语言大模型（NLP）、视觉大模型（CV）和多模态大模型。语言大模型专注于处理文本数据和理解自然语言，而视觉大模型用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值