UniApp日志系统的性能优化与并发控制实战
在移动应用开发中，日志系统是开发者排查问题、分析用户行为的重要工具。对于基于UniApp框架开发的高频交互型应用（如电商、社交类App），日志系统的性能直接影响用户体验和问题排查效率。本文将深入探讨UniApp日志系统在高并发场景下的优化策略，从基础实现到高级并发控制，提供一套完整的解决方案。
1. UniApp日志系统基础架构
UniApp提供了多种本地存储方案，包括同步/异步API、文件系统操作等。对于日志系统而言，我们需要考虑以下几个核心需求：
- 持久化存储：日志需要长期保存，不受应用重启影响
- 高性能写入：在高并发场景下不影响主线程性能
- 日志分类：支持不同级别（DEBUG、INFO、ERROR等）的日志记录
- 日志轮转：按时间或大小自动归档和清理旧日志
基础实现通常使用plus.io文件系统API，以下是一个典型的日志写入函数：
function writeLog(tag, ...messages) { const logEntry = `${new Date().toISOString()} [${tag}] ${messages.join(' ')}\n`; const fileName = getLogFileName(); // 按日期生成文件名 plus.io.requestFileSystem(plus.io.PRIVATE_DOC, fs => { fs.root.getFile(fileName, { create: true }, fileEntry => { fileEntry.createWriter(writer => { writer.seek(writer.length); writer.write(logEntry); }); }); }); }这种基础实现存在明显问题：缺乏并发控制。当多个日志同时写入时，可能出现文件冲突或日志丢失。
2. 高并发场景下的挑战与解决方案
在高并发场景下（如秒杀活动、社交应用热点事件），日志系统面临三大挑战：
- 写入冲突：多个日志同时操作同一文件
- 性能瓶颈：频繁IO操作阻塞主线程
- 日志丢失：异步写入未完成时应用崩溃
2.1 Promise队列控制
最直接的解决方案是引入Promise队列机制，确保日志顺序写入：
let writeQueue = []; let isWriting = false; function enqueueWrite(fileName, data) { return new Promise((resolve, reject) => { writeQueue.push({ fileName, data, resolve, reject }); if (!isWriting) processQueue(); }); } function processQueue() { if (writeQueue.length === 0) { isWriting = false; return; } isWriting = true; const { fileName, data, resolve, reject } = writeQueue.shift(); plus.io.requestFileSystem(plus.io.PRIVATE_DOC, fs => { fs.root.getFile(fileName, { create: true }, fileEntry => { fileEntry.createWriter(writer => { writer.onwrite = () => resolve(); writer.onerror = e => reject(e); writer.seek(writer.length); writer.write(data); }); }); }).then(processQueue, processQueue); }这种方案虽然解决了并发问题，但存在性能瓶颈——所有写入操作都是串行的。
2.2 批量写入优化
我们可以通过批量写入策略提升性能：
- 收集短时间内产生的日志
- 合并为一次写入操作
- 定时刷新缓冲区
const BATCH_INTERVAL = 100; // 100ms批处理窗口 let batchBuffer = []; let batchTimer = null; function scheduleBatchWrite() { if (batchTimer) return; batchTimer = setTimeout(() => { const logsToWrite = batchBuffer.join(''); batchBuffer = []; batchTimer = null; enqueueWrite(getLogFileName(), logsToWrite); }, BATCH_INTERVAL); } function logWithBatching(tag, ...messages) { const logEntry = `${new Date().toISOString()} [${tag}] ${messages.join(' ')}\n`; batchBuffer.push(logEntry); scheduleBatchWrite(); }提示：批量写入的间隔需要权衡 - 间隔太短失去批处理意义，太长可能丢失最近日志
3. 高级并发控制策略
对于超高并发场景，我们需要更精细的控制策略。以下是三种常见方案的对比：
| 策略 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| Promise队列 | 实现简单，保证顺序 | 吞吐量低 | 低并发场景 |
| 批量写入 | 减少IO次数，提高吞吐 | 有延迟，可能丢失最新日志 | 中高并发 |
| 双缓冲+Worker | 最高性能，不影响主线程 | 实现复杂 | 超高并发 |
3.1 Web Worker实现
将日志写入转移到Web Worker中可以彻底解决主线程阻塞问题：
主线程代码：
const loggerWorker = new Worker('logger-worker.js'); function logViaWorker(tag, ...messages) { loggerWorker.postMessage({ type: 'log', payload: { tag, messages } }); }Worker代码 (logger-worker.js)：
let buffer = []; const FLUSH_INTERVAL = 200; setInterval(() => { if (buffer.length === 0) return; const logs = buffer.join(''); buffer = []; // 使用同步XHR或SharedArrayBuffer实现线程安全写入 writeToFile(logs); }, FLUSH_INTERVAL); self.onmessage = (e) => { if (e.data.type === 'log') { const { tag, messages } = e.data.payload; buffer.push(`${Date.now()} [${tag}] ${messages.join(' ')}\n`); } };4. 性能优化实战技巧
4.1 日志分级控制
生产环境应避免记录过多DEBUG日志：
const LOG_LEVEL = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 }; let currentLevel = LOG_LEVEL.INFO; function setLogLevel(level) { currentLevel = level; } function debug(...messages) { if (currentLevel <= LOG_LEVEL.DEBUG) { logWithBatching('DEBUG', ...messages); } }4.2 日志文件轮转
防止日志文件无限增长：
const MAX_LOG_SIZE = 1024 * 1024; // 1MB const MAX_LOG_DAYS = 7; function checkLogRotation(fileEntry) { fileEntry.file(file => { if (file.size > MAX_LOG_SIZE) { const newName = `${Date.now()}.log`; fileEntry.moveTo(null, newName); } }); } // 定期清理旧日志 function cleanupOldLogs() { const cutoff = Date.now() - MAX_LOG_DAYS * 86400000; plus.io.requestFileSystem(plus.io.PRIVATE_DOC, fs => { fs.root.getDirectory('logs', {}, dirEntry => { const reader = dirEntry.createReader(); reader.readEntries(entries => { entries.forEach(entry => { if (entry.name.endsWith('.log') && parseInt(entry.name.split('.')[0]) < cutoff) { entry.remove(); } }); }); }); }); }4.3 内存缓存优化
对于频繁产生的相同日志，可以使用内存缓存去重：
const logCache = new Map(); const CACHE_TTL = 5000; // 5秒 function logWithCache(tag, ...messages) { const key = `${tag}:${messages.join('')}`; const now = Date.now(); if (!logCache.has(key) || now - logCache.get(key) > CACHE_TTL) { logWithBatching(tag, ...messages); logCache.set(key, now); } }5. 异常处理与监控
健壮的日志系统需要监控自身的健康状况：
5.1 写入失败处理
function writeWithRetry(fileName, data, retries = 3) { return new Promise((resolve, reject) => { const attempt = () => { plus.io.requestFileSystem(plus.io.PRIVATE_DOC, fs => { // ...写入逻辑 }, error => { if (retries > 0) { setTimeout(() => { attempt(); retries--; }, 100); } else { reject(error); // 降级方案：存入内存或发送到网络 emergencyCache.push({ fileName, data }); } }); }; attempt(); }); }5.2 性能监控
const perfStats = { totalLogs: 0, failedWrites: 0, avgWriteTime: 0 }; function logWithMonitoring(tag, ...messages) { const start = performance.now(); return logWithBatching(tag, ...messages).then(() => { const duration = performance.now() - start; perfStats.totalLogs++; perfStats.avgWriteTime = (perfStats.avgWriteTime * (perfStats.totalLogs - 1) + duration) / perfStats.totalLogs; }, () => { perfStats.failedWrites++; }); }在实际项目中，我们曾遇到高峰期日志丢失问题。通过引入二级缓存和指数退避重试机制，将日志丢失率从5%降至0.1%以下。关键是在内存中维护一个待写入队列，当文件写入失败时自动重试，同时限制队列大小防止内存溢出。
