讨论广场 问答详情
主线程被一个同步循环卡了 5 秒,ANR 弹窗都出来了
bug菌¹ 2026-11-10 09:36:12
赞 10 评论 分享
鸿蒙问答专区

有个数据同步逻辑,需要遍历几万条记录做比对,跑在主线程上直接卡死,系统弹了"应用无响应"。

这个循环本身逻辑不复杂,就是量大。除了丢到 Worker,还有别的办法吗?

赞 10 评论 分享
写回答
全部评论(3)
3 楼

先说结论:几万条的遍历不能整个丢 Worker 就完事,要做"分片 + 让出主线程 + 进度反馈"三件事。

① 为什么不能只丢 Worker

如果放 Worker 里,虽然主线程不卡了,但:

  • 一次性处理几万条会有很长时间没进度,用户以为卡死;

  • 大数据在主线程和 Worker 之间传输成本很高(序列化)。

② 推荐做法:在 UI 线程做"分片异步"(适用于中等数据量)

async function processInChunks<T>(
  list: T[],
  chunkSize: number,
  handler: (item: T) => void,
  onProgress?: (done: number, total: number) => void
): Promise<void> {
  const total = list.length
  for (let i = 0; i < total; i += chunkSize) {
    const end = Math.min(i + chunkSize, total)
    for (let j = i; j < end; j++) {
      handler(list[j])
    }
    onProgress?.(end, total)
​
    // 关键:让出主线程,让 UI 有机会刷新
    await new Promise<void>(resolve => setTimeout(resolve, 0))
  }
}
// 使用
await processInChunks(this.records, 200, (r) => {
  compareAndMark(r)
}, (done, total) => {
  this.progress = done / total        // 进度条实时更新,用户不焦虑
})

每 200 条让出一次,主线程的卡顿从 5 秒降到 200 条的处理时间(几十毫秒),人眼感知不到。

③ 数据量特别大(几十万条以上):用 TaskPool + 分片

@Concurrent
function processChunk(startIndex: number, endIndex: number, raw: ArrayBuffer): number {
  // 用 ArrayBuffer/TypedArray 传递,避免字符串序列化
  const view = new Uint32Array(raw)
  let count = 0
  for (let i = startIndex; i < endIndex; i++) {
    if (needProcess(view[i])) { count++ }
  }
  return count
}
​
async function syncLargeData(data: Uint32Array) {
  const total = data.length
  const CHUNK = 5000
  const tasks: taskpool.Task[] = []
​
  for (let i = 0; i < total; i += CHUNK) {
    const end = Math.min(i + CHUNK, total)
    // 传 ArrayBuffer,走共享/转移,避免复制
    tasks.push(new taskpool.Task(processChunk, i, end, data.buffer))
  }
​
  // 并发执行,用 TaskPool 自动调度
  const results = await taskpool.execute(tasks) as number[]
  const sum = results.reduce((a, b) => a + b, 0)
  console.info(`total matched: ${sum}`)
}

注意:data.buffer 传过去会被转移(原 buffer 失效)。如果不希望转移,传副本 data.buffer.slice(0),代价是内存翻倍。

④ 让用户可感知、可取消

@State progress: number = 0
@State canCancel: boolean = true
private cancelled: boolean = false
​
async function run() {
  for (let i = 0; i < this.records.length; i += 200) {
    if (this.cancelled) { break }        // 支持取消
    // ... 处理
    this.progress = i / this.records.length
    await sleep(0)
  }
}

长任务必须有进度和取消入口,否则用户只能强杀应用。

⑤ ANR 的判定标准(心里有个数)

场景阈值
主线程阻塞通常 5 秒左右触发输入事件超时
关键生命周期超时更短(秒级)

任何可能超过 200ms 的同步操作都要考虑异步化。这不是"优化",是"基本要求"。

⑥ 排查手段

DevEco Studio 的 Profiler → Time 面板能抓到主线程的长任务栈,直接定位到是哪个函数卡住的。别只看现象("卡了"),要看到具体的调用栈。

⑦ 一句话总结

主线程只做 UI。任何"需要遍历、需要计算、需要 IO"的事情,要么分片让出,要么丢子线程。分片是成本最低的改造,优先考虑。

1
2026-11-12 14:29:42
2 楼

先说结论:几万条的遍历不能整个丢 Worker 就完事,要做"分片 + 让出主线程 + 进度反馈"三件事。

① 为什么不能只丢 Worker

如果放 Worker 里,虽然主线程不卡了,但:

  • 一次性处理几万条会有很长时间没进度,用户以为卡死;

  • 大数据在主线程和 Worker 之间传输成本很高(序列化)。

② 推荐做法:在 UI 线程做"分片异步"(适用于中等数据量)

async function processInChunks<T>(
  list: T[],
  chunkSize: number,
  handler: (item: T) => void,
  onProgress?: (done: number, total: number) => void
): Promise<void> {
  const total = list.length
  for (let i = 0; i < total; i += chunkSize) {
    const end = Math.min(i + chunkSize, total)
    for (let j = i; j < end; j++) {
      handler(list[j])
    }
    onProgress?.(end, total)
​
    // 关键:让出主线程,让 UI 有机会刷新
    await new Promise<void>(resolve => setTimeout(resolve, 0))
  }
}
// 使用
await processInChunks(this.records, 200, (r) => {
  compareAndMark(r)
}, (done, total) => {
  this.progress = done / total        // 进度条实时更新,用户不焦虑
})

每 200 条让出一次,主线程的卡顿从 5 秒降到 200 条的处理时间(几十毫秒),人眼感知不到。

③ 数据量特别大(几十万条以上):用 TaskPool + 分片

@Concurrent
function processChunk(startIndex: number, endIndex: number, raw: ArrayBuffer): number {
  // 用 ArrayBuffer/TypedArray 传递,避免字符串序列化
  const view = new Uint32Array(raw)
  let count = 0
  for (let i = startIndex; i < endIndex; i++) {
    if (needProcess(view[i])) { count++ }
  }
  return count
}
​
async function syncLargeData(data: Uint32Array) {
  const total = data.length
  const CHUNK = 5000
  const tasks: taskpool.Task[] = []
​
  for (let i = 0; i < total; i += CHUNK) {
    const end = Math.min(i + CHUNK, total)
    // 传 ArrayBuffer,走共享/转移,避免复制
    tasks.push(new taskpool.Task(processChunk, i, end, data.buffer))
  }
​
  // 并发执行,用 TaskPool 自动调度
  const results = await taskpool.execute(tasks) as number[]
  const sum = results.reduce((a, b) => a + b, 0)
  console.info(`total matched: ${sum}`)
}

注意:data.buffer 传过去会被转移(原 buffer 失效)。如果不希望转移,传副本 data.buffer.slice(0),代价是内存翻倍。

④ 让用户可感知、可取消

@State progress: number = 0
@State canCancel: boolean = true
private cancelled: boolean = false
​
async function run() {
  for (let i = 0; i < this.records.length; i += 200) {
    if (this.cancelled) { break }        // 支持取消
    // ... 处理
    this.progress = i / this.records.length
    await sleep(0)
  }
}

长任务必须有进度和取消入口,否则用户只能强杀应用。

⑤ ANR 的判定标准(心里有个数)

场景阈值
主线程阻塞通常 5 秒左右触发输入事件超时
关键生命周期超时更短(秒级)

任何可能超过 200ms 的同步操作都要考虑异步化。这不是"优化",是"基本要求"。

⑥ 排查手段

DevEco Studio 的 Profiler → Time 面板能抓到主线程的长任务栈,直接定位到是哪个函数卡住的。别只看现象("卡了"),要看到具体的调用栈。

⑦ 一句话总结

主线程只做 UI。任何"需要遍历、需要计算、需要 IO"的事情,要么分片让出,要么丢子线程。分片是成本最低的改造,优先考虑。

赞
2026-11-12 14:29:39

可以用 TaskPool:把比对逻辑写成 @Concurrent 函数,传入数据,通过 taskpool.execute 执行,结果回主线程后再更新 UI。

短任务也可分批处理,每批之间让出事件循环;单纯套 async/Promise 不会让同步循环离开主线程。

若是双重遍历,优先建 Map 索引,减少比对次数,再考虑并发。

赞
2026-11-11 03:30:49