有个数据同步逻辑,需要遍历几万条记录做比对,跑在主线程上直接卡死,系统弹了"应用无响应"。
这个循环本身逻辑不复杂,就是量大。除了丢到 Worker,还有别的办法吗?
先说结论:几万条的遍历不能整个丢 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"的事情,要么分片让出,要么丢子线程。分片是成本最低的改造,优先考虑。
先说结论:几万条的遍历不能整个丢 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"的事情,要么分片让出,要么丢子线程。分片是成本最低的改造,优先考虑。
可以用 TaskPool:把比对逻辑写成 @Concurrent 函数,传入数据,通过 taskpool.execute 执行,结果回主线程后再更新 UI。
短任务也可分批处理,每批之间让出事件循环;单纯套 async/Promise 不会让同步循环离开主线程。
若是双重遍历,优先建 Map 索引,减少比对次数,再考虑并发。
