文档开发者中心
我的
|

HarmonyOS 6

HarmonyOS 5

#ArkTS高效运行#别让属性访问拖垮性能:ArkTS Inline Cache 实战指南

本文档面向 ArkTS / NAPI 开发者,主要介绍运行时的 Inline Cache(内联缓存,简称 IC) 是什么、为什么它决定了属性访问的快慢,以及怎样写代码才能让它发挥最大作用。


目录

  1. 没有 IC 的代价:每次属性访问都是一次"全量查找"
  2. IC 的魔法:用一次比较,换一次直接读取
  3. 好写法:4 招把 IC 命中率拉满
  4. IC 杀手榜:这些写法正在拖垮你的性能
  5. NAPI 篇:native 侧怎么访问 ArkTS 对象最快
  6. 一页纸自查:你的代码对 IC 友好吗?

1. 没有 IC 的代价:每次属性访问都是一次"全量查找"

1.1 属性访问,没你想的那么"免费"

ArkTS / JavaScript 是动态语言:对象能在运行时随意增删属性。所以当你写下 obj.x 时,引擎没法在编译期就知道 x 在对象的哪个内存位置上。

如果完全不做优化,每一次 obj.x 都得执行一遍完整查找:

收起
自动换行
深色代码主题
复制
1. 在对象自身的属性表里逐个找 "x"
2. 找不到 → 沿原型链一层层往上找
3. 每一层都要比较字符串名、读属性信息
4. 最终拿到位置,再读出值

这是一次逐层、逐属性的查找,放进 for 循环里反复执行,开销非常明显。

1.2 IC 的核心思路:记住上次的答案,下次直接抄

IC 基于一个朴素但极其有效的观察:同一个调用点(一行代码),运行时反复遇到的对象"形状"往往是高度重复的。

比如:

收起
自动换行
深色代码主题
复制
function getX(p: Point) { return p.x; }   // 这里的 p.x,几乎都是 Point 形状

既然如此,那就把上一次"怎么找到 x 的"记下来。下次再走到这里:

  • 先快速确认"这次的对象形状,和上次记下来的一样吗?"
  • 一样 → 直接用上次记好的位置读值,跳过整段查找。

这就是 IC。它是一种"用历史换未来"的加速。

1.3 一句话总结:IC 把动态属性访问,拉到静态字段的速度

没有 IC,每次属性访问都是一次完整查找(慢);有了 IC 但写法不当导致它记不住答案,又退回完整查找(同样慢)。

IC 让动态语言的属性访问逼近静态语言的字段访问速度——前提是开发者写出"形状稳定"的代码。 这正是本文要讲的。


2. IC 的魔法:用一次比较,换一次直接读取

这一节只讲和你写代码有关的核心原理,不涉及引擎内部实现细节。

2.1 什么是"形状"?IC 就靠它认人

运行时给每个对象都挂了一个"隐藏类",它记录了这个对象的形状:有哪些属性、属性排列顺序、属性值的大致类型、原型是谁。

关键规则:形状相同的对象,共用同一个隐藏类(同一个内存指针)。 形状一旦改变(加属性、删属性、改原型、改字段类型),对象就会换一个新的隐藏类。

收起
自动换行
深色代码主题
复制
const a = { x: 1, y: 2 };   // a 和 b 形状一样 → 共用同一个隐藏类
const b = { x: 3, y: 4 };
const c = { x: 5 };          // c 属性更少 → 另一个隐藏类

2.2 命中的真相:一次比较 + 直接读值

IC 在每个调用点记住的是 "上次的隐藏类 + 上次 x 的位置"。下次访问时,判定极其简单:

收起
自动换行
深色代码主题
复制
取当前对象的隐藏类指针,和记住的指针比一比:
  相同 → 形状没变 → 直接去记住的位置读值。
  不同 → 形状变了 → 老老实实重新查找,顺便把新形状记下来。

因为"形状相同"就等于"隐藏类指针相同",所以确认形状只需一次指针比较——这是 IC 高效的根本原因,不需要逐个比对属性名。

2.3 单态 / 多态 / 超态:见过的形状越多,越慢

IC 在一个调用点见过的形状越多,要记的东西就越多,判定也越慢。大致分三档:

情况 含义 性能
单态(只见过 1 种形状) 记一条,一次比较即可 🟢 最快,理想状态
多态(见过少量几种形状) 记几条,每次要逐条比 🟡 变慢
超态(见过太多形状) 记不过来,干脆放弃缓存 🔴 最慢,退回每次完整查找

这一节最重要的结论:同一行属性访问代码,反复遇到的对象形状越少越好。 理想情况是只遇到一种形状(单态)。如果一个调用点总在处理五花八门形状的对象,IC 会一路退化到"放弃缓存",等于白搭。第 4 节那些"坏写法",本质上都在制造这种情况。

2.4 两个动作,能让你的 IC 集体"失忆"

有两类情况会让 IC 记住的答案作废,下次重新查找:

  1. 对象自己变形了:增删属性、改原型、改字段类型——对象换了新隐藏类,旧记忆对它不再成立。
  2. 原型链被改了:原型链上的对象一旦被修改,运行时会让所有"依赖这条原型链"的 IC 全部失效。

    也就是说,给 Foo.prototype 加方法,会让所有 foo 实例上访问原型方法的 IC 集体失效。这点容易被忽略,影响面很大。

理解了上面这些,你就理解了后面所有"好/坏写法"背后的原因。


3. 好写法:4 招把 IC 命中率拉满

本节按重要性从高到低排列。第 1 条做好了,能解决大部分问题。

3.1 ⭐ 用 class + 构造函数全量初始化(最重要的一招)

class 的形状在编译期就定死了,所有实例天生共用同一个隐藏类,IC 自动处于最快的单态。

收起
自动换行
深色代码主题
复制
class Point {
  x: number;
  y: number;

  constructor(x: number, y: number) {
    this.x = x;   // 构造函数里把所有属性都赋上
    this.y = y;
  }
}

function distanceFromOrigin(p: Point): number {
  // p.x / p.y 这一调用点只见过 Point 一种形状 → 单态命中
  return Math.sqrt(p.x * p.x + p.y * p.y);
}

const points: Point[] = [ /* 大量 Point 实例 */ ];
let sum = 0;
for (const p of points) {
  sum += distanceFromOrigin(p);   // 每次访问都命中 IC
}

为什么这条最重要:它能从根上保证"一类对象一个形状"。而且构造函数一次性赋值,让对象尺寸尽早定型,形状更稳定。

3.2 对象字面量:属性名和顺序要"千人一面"

即便不用 class,写对象字面量时也要保证"同类"字面量的属性名和顺序完全一致。运行时会按字面量的属性个数和顺序复用隐藏类,顺序一致的对象会共用同一个隐藏类。

收起
自动换行
深色代码主题
复制
interface Config { width: number; height: number; title: string; }

function makeConfig(): Config {
  return { width: 100, height: 200, title: "win" };   // 每次都这个顺序
}

function area(c: Config): number {
  return c.width * c.height;   // 单态命中
}

3.3 数组别混搭:元素同构才够快

数组的元素类型也属于"形状"的一部分。一个数组里全是 number,访问 arr[i] 会走专门的高速通道;如果混入不同类型,会触发元素类型切换,相关 IC 失效。

收起
自动换行
深色代码主题
复制
const xs: number[] = [1, 2, 3, 4, 5];   // 同构数组
let s = 0;
for (let i = 0; i < xs.length; i++) {
  s += xs[i];                            // 高效
}

3.4 要分类?用不同的 class,别用"标志位对象"

收起
自动换行
深色代码主题
复制
// ✅ 推荐:不同类别用不同 class,各自都是单态
class Circle { constructor(public r: number) {} }
class Square { constructor(public side: number) {} }

// ❌ 避免:用一个对象 + type 标志位勉强区分,容易长成多种形状
// const s1 = { type: "circle", r: 1 };
// const s2 = { type: "square", side: 2 /* 可能还有别的字段,也可能没有 */ };

4. IC 杀手榜:这些写法正在拖垮你的性能

本节按"对性能的危害程度 × 出现频率"从高到低排列。前三条是重灾区。

4.1 🔥 超态:一个调用点见到多种形状(头号杀手)

这是 IC 性能的头号杀手,而且很隐蔽。当一行属性访问代码反复面对形状各异的对象时,IC 从单态退化到多态,形状再多点就直接放弃缓存。

收起
自动换行
深色代码主题
复制
// ❌ 避免:一个调用点接收各种形状的"鸭子类型"对象
function getValue(obj: any): number {
  return obj.value;   // 这里会见到 {a,value}、{b,c,value}、{value,d,e}... 多种形状
}

const list = [
  { a: 1, value: 10 },
  { b: 2, c: 3, value: 20 },
  { value: 30, d: 4 },
];
list.forEach(o => getValue(o));   // IC 一路退化到放弃
收起
自动换行
深色代码主题
复制
// ✅ 改进:统一形状,用 interface/class 约束
interface Holder { value: number; }
function getValue(obj: Holder): number {
  return obj.value;   // 只见这一种形状 → 单态
}

同一个根因的另外两种表现:运行时按条件动态挂属性(if (...) obj.extra = ...)、同类对象以不同顺序/不同属性名构造。它们都会让"本应同形"的对象长成多种形状,效果和上面一样糟。统一在构造时就定好全部字段(缺失的给默认值)即可。

4.2 🔥 delete:一行代码让对象"破相"

delete obj.x 不仅改变形状,还经常把对象整个转成"字典模式"。一旦进入字典模式,运行时会直接放弃 IC,每次访问都做哈希查找。

收起
自动换行
深色代码主题
复制
// ❌ 避免
const obj: Record<string, number> = { a: 1, b: 2, c: 3 };
delete obj.b;            // 形状改变 + 可能字典化 → 该对象 IC 全部失效

// ✅ 替代:用"置默认值"表达逻辑删除,保持形状不变
obj.b = 0;

4.3 运行时改原型:一次修改,全员失效

改原型链(obj.__proto__ = ...、Object.setPrototypeOf、给 Foo.prototype 追加方法)会让所有依赖这条原型链的 IC 集体失效,影响面远超一个对象。

收起
自动换行
深色代码主题
复制
// ❌ 避免:运行时改原型
const obj = {};
obj.__proto__ = someOther;

// ❌ 避免:热路径中给 prototype 追加方法
Foo.prototype.newMethod = function () { /* ... */ };
收起
自动换行
深色代码主题
复制
// ✅ 改进:类定义阶段就把结构写完整
class Foo {
  newMethod() { /* ... */ }
}

4.4 同名字段类型反复横跳

同一个属性名,先存 number、再存 string、再存对象,会触发隐藏类的字段类型变更,相关 IC 失效。

收起
自动换行
深色代码主题
复制
// ❌ 避免
const o: any = {};
o.v = 1;        // number
o.v = "hi";     // 切到 string → 形状变,IC miss
o.v = {};       // 再切到 object → 再次 miss

// ✅ 改进:字段类型固定
class Container { v: number = 0; }

4.5 属性过多 / 稀疏数组:滑入"字典模式"

  • 单个对象属性数量过多(远超常规规模),会被强制转字典模式,IC 放弃缓存。
  • 稀疏数组(下标跳跃极大)也会触发字典化。
收起
自动换行
深色代码主题
复制
// ❌ 避免:超大稀疏数组
const sparse: any[] = [];
sparse[0] = 1;
sparse[100000] = 2;     // 稀疏 → elements 字典化

4.6 freeze / seal / preventExtensions:冻结要挑对象

这些操作会改变对象的扩展性,触发隐藏类变更。对热路径中频繁访问的对象慎用;用于配置常量等访问不频繁的对象无妨。


5. NAPI 篇:native 侧怎么访问 ArkTS 对象最快

写 C/C++ NAPI 模块、需要从 native 侧读写 ArkTS 对象属性时,请阅读本节。

这里用的接口是 #include <napi/native_api.h>(仓库路径 interfaces/kits/napi/native_api.h)里的标准对外 C API。

5.1 先分清两种场景:偶发 vs 紧循环

native 侧访问 ArkTS 对象属性,要不要专门为 IC 费心,取决于访问频率:

场景 该怎么做
偶发访问(偶尔读一两个属性) 直接用标准属性 API(napi_get_named_property / napi_get_property)即可,不用管 IC。只要对象形状稳定(见第 3、4 节),它本身就够快。
紧循环访问(在 C++ 循环里成千上万次读/写同一属性) 用本节介绍的 callsite IC API,能拿到和 ArkTS 字节码同等的访问速度。

下面分别说明。

5.2 偶发访问:标准属性 API 就够

最常见的用法,按需取值即可。第 3、4 节的好/坏写法对它同样有效——ArkTS 对象形状越稳定,native 侧访问也越快;千万别从 native 侧 delete 一个热路径对象的属性。

收起
自动换行
深色代码主题
复制
napi_value val;
// 按名字取属性
napi_get_named_property(env, obj, "x", &val);
// 或按键取属性(key 是一个 napi_value)
napi_get_property(env, obj, key, &val);

为什么"偶发"不用管 IC?因为 IC 是按"调用点"记录历史的,而普通的 napi_get_named_property(env, obj, "x") 只是一次 C 函数调用,天生没有"调用点"这个身份,引擎无法把缓存挂在它身上。所以偶发场景下它的加速主要来自"对象形状稳定",而非性能敏感的 IC。当你确实在紧循环里反复访问时,就需要下一节的 API 了。

5.3 紧循环访问:上 callsite IC API ⭐

引擎专门提供了一组 callsite IC API,让你手动给某一处属性访问指定一个"调用点缓存"。用上之后,在 native 紧循环里反复读写同一属性,就能命中真正的 IC,等价于"一次形状比较 + 直接按位置读",和 ArkTS 字节码一样快。

对外 C API(napi/native_api.h):

收起
自动换行
深色代码主题
复制
// 1) 创建一个"调用点缓存"。每个固定访问点创建一次,长期复用。
napi_status napi_create_callsite_info(napi_env env, napi_callsite_info* result);

// 2) 用完释放,避免泄漏。
napi_status napi_delete_callsite_info(napi_env env, napi_callsite_info info);

// 3) 读属性(走 IC;未命中时自动回退到 napi_get_property,无需自己写兜底)
//    hit:可选,命中 IC 为 true,未命中为 false,便于观测
napi_status napi_get_property_with_callsite_info(
    napi_env env, napi_value object, napi_value key,
    napi_callsite_info info, napi_value* result, bool* hit);

// 4) 写属性(走 IC;未命中时自动回退到 napi_set_property)
napi_status napi_set_property_with_callsite_info(
    napi_env env, napi_value object, napi_value key, napi_value value,
    napi_callsite_info info, bool* hit);

示例:在 native 紧循环里反复读 ArkTS 对象的同一属性

假设 ArkTS 侧有一组 Point 对象组成的数组,native 侧需要把它们全部的 x 累加起来:

收起
自动换行
深色代码主题
复制
#include <napi/native_api.h>

// 对应"读 obj.x"这一处访问的调用点缓存,模块级长期持有
static napi_callsite_info g_getXInfo = NULL;

napi_value SumX(napi_env env, napi_callback_info cbinfo)
{
    // 1) 取参数:ArkTS 传进来的 Point[]
    size_t argc = 1;
    napi_value args[1];
    napi_get_cb_info(env, cbinfo, &argc, args, NULL, NULL);
    napi_value arr = args[0];

    // 2) 懒初始化调用点缓存:第一次进入时创建,之后长期复用
    if (g_getXInfo == NULL) {
        napi_create_callsite_info(env, &g_getXInfo);
    }

    // 3) key "x" 也只创建一次,不要每次循环都新建
    napi_value keyX;
    napi_create_string_utf8(env, "x", NAPI_AUTO_LENGTH, &keyX);

    uint32_t len = 0;
    napi_get_array_length(env, arr, &len);

    double sum = 0;
    for (uint32_t i = 0; i < len; i++) {
        napi_value elem;
        napi_get_element(env, arr, i, &elem);   // 取出第 i 个 Point

        bool hit = false;
        napi_value val;
        // 关键调用:带上 g_getXInfo,这一处访问就会走 IC
        napi_get_property_with_callsite_info(env, elem, keyX, g_getXInfo, &val, &hit);
        // 第一次 hit=false(缓存为空,回退查找并记下形状)
        // 之后只要对象形状一致,hit=true,等价于直接按位置读

        double x = 0;
        napi_get_value_double(env, val, &x);
        sum += x;
    }

    napi_value result;
    napi_create_double(env, sum, &result);
    return result;
}

模块卸载或确定不再使用时,记得释放:

收起
自动换行
深色代码主题
复制
void OnCleanup(napi_env env)
{
    if (g_getXInfo != NULL) {
        napi_delete_callsite_info(env, g_getXInfo);
        g_getXInfo = NULL;
    }
}

5.4 用 callsite IC 的 5 条军规

  1. 一个调用点一个缓存,长期复用。 napi_create_callsite_info 返回的句柄就是那一处访问的"记忆"。在固定位置反复用同一个句柄,IC 才会从空 → 单态 → 持续命中。千万不要每次访问都新建/删除,那样永远停在"空",毫无收益。

  2. 未命中会自动回退,无需自己兜底。 接口注释明确写了"Fallback to napi_get_property / napi_set_property"。所以你写的逻辑和用标准 API 完全等价,只是多了一条 IC 快路径。

  3. hit 出参可用于观测。 想确认这处访问是否真的命中了 IC,把 bool* hit 传进来检查即可。如果一直 false,多半是对象形状不稳定(回到第 4 节排查)。

  4. 形状稳定才有收益。 和所有 IC 一样,它只在反复访问同形状对象时加速。如果这处访问面对的对象形状五花八门,它也会退化,此时改用它意义不大——先治理对象形状。

  5. key、callsite info 都尽量复用,别在循环里反复创建。 把它们提到循环外。

简单概括 native 侧的取舍:偶发访问用标准 API;紧循环反复读写同一属性,用 callsite IC API。 两种情况下,"保持 ArkTS 对象形状稳定"都是前提。


6. 一页纸自查:你的代码对 IC 友好吗?

写完一段属性访问密集的代码后,对照下表自查。

✅ 友好(命中率高)

  • 用 class / interface 定义结构,访问点只见少数几种确定形状。
  • 构造函数里一次性、固定顺序初始化全部字段(缺的给默认值)。
  • 数组元素同构(同类型、同 class)。
  • 同类对象字面量的属性名和顺序一致。
  • 字段类型稳定(不反复切换 number/string/object)。
  • NAPI 紧循环访问 ArkTS 属性时,用了 callsite IC API 且句柄被复用。

❌ 不友好(命中率低)

  • 同一处属性访问面对多种形状的对象(超态)—— 头号问题。
  • 运行时动态增删属性、同类对象构造顺序不一。
  • 使用了 delete(尤其对热路径对象)。
  • 运行时修改 __proto__ / Object.setPrototypeOf / 给 prototype 追加成员。
  • 同名字段反复改类型。
  • 对象属性过多或使用了稀疏数组(进入字典模式)。
  • 对热路径对象频繁 Object.freeze / seal / preventExtensions。
  • NAPI 侧动态增删 ArkTS 对象属性,破坏其形状。

点赞
收藏
回复
1
分享
举报
浏览3 发布于4天前上海
全部评论
最多点赞
最新发布
最早发布
写回答
新增插入模板功能
一键使用模板,快速填写内容,轻松发帖~
知道了
  • 为了保障您的信息安全,请勿上传您的敏感个人信息(如您的密码等信息)和您的敏感资产信息(如关键源代码、签名私钥、调试安装包、业务日志等信息),且您需自行承担由此产生的信息泄露等安全风险。
  • 如您发布的内容为转载内容,请注明内容来源。

我要发帖子

了解社区公约,与您携手共创和谐专业的开发者社区。