HarmonyOS开发分布式场景性能优化：延迟与带宽优化

在分布式场景下，性能优化是一个全新的课题——不仅要考虑单设备性能，还要考虑跨设备通信的延迟和带宽。一个精心设计的分布式应用，能够在保证功能完整的前提下，实现毫秒级响应和流畅体验。这篇文章带你深入理解分布式场景下的性能优化策略。

一、背景与动机：为什么需要分布式性能优化？

1.1 分布式场景的性能挑战

在分布式场景下，性能瓶颈与传统单设备场景完全不同：

网络延迟：跨设备通信需要经过网络传输，即使是最优条件下的局域网，也有毫秒级的延迟。如果设计不当，用户操作可能需要等待数百毫秒才能得到响应。

带宽限制：虽然Wi-Fi和5G提供了高速连接，但在实际场景中，可用带宽受多种因素影响——设备距离、信号强度、网络拥塞、其他应用占用等。

数据序列化：跨设备传输数据需要序列化和反序列化，这个过程会消耗CPU时间，增加延迟。

协议开销：通信协议的头部、确认包、重传机制等都会产生额外开销，降低有效带宽。

1.2 性能优化的价值

优化分布式场景性能，能够显著提升用户体验：

性能优化的核心价值：

二、核心原理：分布式性能模型

2.1 延迟模型

2.1.1 延迟组成

分布式场景下的总延迟由多个部分组成：

总延迟 = 处理延迟 + 序列化延迟 + 传输延迟 + 传播延迟 + 排队延迟

// 延迟模型定义
interface LatencyModel {
  // 处理延迟：应用层处理时间
  processingDelay: number;     // ms
  
  // 序列化延迟：数据序列化/反序列化时间
  serializationDelay: number;  // ms
  
  // 传输延迟：数据包发送时间
  transmissionDelay: number;   // ms = 数据大小 / 带宽
  
  // 传播延迟：信号传播时间
  propagationDelay: number;    // ms = 距离 / 光速
  
  // 排队延迟：网络排队等待时间
  queuingDelay: number;        // ms
}

// 计算总延迟
function calculateTotalLatency(model: LatencyModel): number {
  return model.processingDelay +
         model.serializationDelay +
         model.transmissionDelay +
         model.propagationDelay +
         model.queuingDelay;
}

2.1.2 延迟优化策略

2.2 带宽模型

2.2.1 带宽影响因素

// 带宽模型定义
interface BandwidthModel {
  // 理论带宽：物理链路最大带宽
  theoreticalBandwidth: number;  // Mbps
  
  // 实际带宽：考虑各种因素后的可用带宽
  effectiveBandwidth: number;    // Mbps
  
  // 影响因素
  factors: BandwidthFactors;
}

// 带宽影响因素
interface BandwidthFactors {
  // 信号强度（无线网络）
  signalStrength: number;        // 0-100
  
  // 网络拥塞程度
  congestionLevel: number;       // 0-100
  
  // 其他应用占用
  otherAppUsage: number;         // Mbps
  
  // 协议开销比例
  protocolOverhead: number;      // 0-1
}

// 计算有效带宽
function calculateEffectiveBandwidth(model: BandwidthModel): number {
  const { theoreticalBandwidth, factors } = model;
  
  // 信号强度影响
  const signalFactor = factors.signalStrength / 100;
  
  // 拥塞影响
  const congestionFactor = 1 - (factors.congestionLevel / 100);
  
  // 其他应用占用
  const availableBandwidth = theoreticalBandwidth - factors.otherAppUsage;
  
  // 协议开销
  const protocolFactor = 1 - factors.protocolOverhead;
  
  return availableBandwidth * signalFactor * congestionFactor * protocolFactor;
}

2.2.2 带宽优化策略

graph LR
    A[带宽优化] --> B[数据压缩]
    A --> C[增量同步]
    A --> D[智能路由]
    A --> E[流量控制]
    
    B --> B1[无损压缩]
    B --> B2[有损压缩]
    B --> B3[差分编码]
    
    C --> C1[变更检测]
    C --> C2[增量传输]
    C --> C3[合并优化]
    
    D --> D1[路径选择]
    D --> D2[负载均衡]
    D --> D3[故障转移]
    
    E --> E1[发送窗口]
    E --> E2[接收窗口]
    E --> E3[拥塞控制]
    
    classDef primary fill:#4A90E2,stroke:#2E5C8A,stroke-width:2px,color:#fff
    classDef warning fill:#F5A623,stroke:#C17A00,stroke-width:2px,color:#fff
    classDef info fill:#7ED321,stroke:#5BA315,stroke-width:2px,color:#fff
    
    class A primary
    class B,C,D,E warning
    class B1,B2,B3,C1,C2,C3,D1,D2,D3,E1,E2,E3 info

2.3 性能监控模型

// 性能监控指标
interface PerformanceMetrics {
  // 延迟指标
  latency: {
    avg: number;         // 平均延迟（ms）
    min: number;         // 最小延迟
    max: number;         // 最大延迟
    p50: number;         // 50分位延迟
    p95: number;         // 95分位延迟
    p99: number;         // 99分位延迟
  };
  
  // 吞吐量指标
  throughput: {
    bytesPerSecond: number;   // 字节/秒
    packetsPerSecond: number; // 包/秒
    requestsPerSecond: number; // 请求/秒
  };
  
  // 错误指标
  errors: {
    lossRate: number;    // 丢包率（0-1）
    errorRate: number;   // 错误率（0-1）
    retryCount: number;  // 重试次数
  };
  
  // 资源指标
  resources: {
    cpuUsage: number;    // CPU使用率（0-1）
    memoryUsage: number; // 内存使用率（0-1）
    networkUsage: number; // 网络使用率（0-1）
    powerConsumption: number; // 功耗（mW）
  };
}

三、代码实战：性能优化实现

3.1 延迟优化：本地缓存

/**
 * 分布式数据缓存
 * 减少跨设备数据访问延迟
 */
export class DistributedDataCache {
  private cache: Map<string, CacheEntry> = new Map();
  private config: CacheConfig;
  private stats: CacheStats = {
    hits: 0,
    misses: 0,
    evictions: 0
  };
  
  constructor(config: CacheConfig) {
    this.config = config;
    
    // 定期清理过期缓存
    setInterval(() => {
      this.cleanup();
    }, config.cleanupInterval);
  }
  
  /**
   * 获取数据（优先从缓存）
   */
  async get<T>(key: string): Promise<T | null> {
    // 检查缓存
    const entry = this.cache.get(key);
    
    if (entry && !this.isExpired(entry)) {
      // 缓存命中
      this.stats.hits++;
      entry.lastAccessTime = Date.now();
      entry.accessCount++;
      
      console.debug(`[Cache] 命中: ${key}`);
      return entry.data as T;
    }
    
    // 缓存未命中
    this.stats.misses++;
    
    // 如果配置了自动加载，从远程加载
    if (this.config.autoLoad && this.config.loader) {
      const data = await this.config.loader(key);
      
      if (data !== null) {
        await this.set(key, data);
        return data as T;
      }
    }
    
    return null;
  }
  
  /**
   * 设置缓存
   */
  async set<T>(key: string, data: T, ttl?: number): Promise<void> {
    // 检查缓存容量
    if (this.cache.size >= this.config.maxSize) {
      this.evict();
    }
    
    // 创建缓存条目
    const entry: CacheEntry = {
      key: key,
      data: data,
      createTime: Date.now(),
      lastAccessTime: Date.now(),
      accessCount: 0,
      ttl: ttl || this.config.defaultTtl,
      size: this.calculateSize(data)
    };
    
    this.cache.set(key, entry);
    
    console.debug(`[Cache] 设置: ${key}, TTL: ${entry.ttl}ms`);
  }
  
  /**
   * 预取数据
   */
  async prefetch(keys: string[]): Promise<void> {
    if (!this.config.loader) {
      return;
    }
    
    // 并行预取
    const promises = keys.map(async key => {
      // 检查是否已缓存
      if (this.cache.has(key)) {
        return;
      }
      
      // 从远程加载
      const data = await this.config.loader!(key);
      
      if (data !== null) {
        await this.set(key, data);
      }
    });
    
    await Promise.all(promises);
    
    console.info(`[Cache] 预取完成: ${keys.length}个`);
  }
  
  /**
   * 使缓存失效
   */
  async invalidate(key: string): Promise<void> {
    this.cache.delete(key);
    console.debug(`[Cache] 失效: ${key}`);
  }
  
  /**
   * 批量失效
   */
  async invalidateBatch(keys: string[]): Promise<void> {
    keys.forEach(key => this.cache.delete(key));
    console.info(`[Cache] 批量失效: ${keys.length}个`);
  }
  
  /**
   * 清空缓存
   */
  clear(): void {
    this.cache.clear();
    console.info('[Cache] 清空');
  }
  
  /**
   * 检查是否过期
   */
  private isExpired(entry: CacheEntry): boolean {
    return Date.now() - entry.createTime > entry.ttl;
  }
  
  /**
   * 清理过期缓存
   */
  private cleanup(): void {
    const now = Date.now();
    const expiredKeys: string[] = [];
    
    this.cache.forEach((entry, key) => {
      if (now - entry.createTime > entry.ttl) {
        expiredKeys.push(key);
      }
    });
    
    expiredKeys.forEach(key => this.cache.delete(key));
    
    if (expiredKeys.length > 0) {
      console.debug(`[Cache] 清理过期: ${expiredKeys.length}个`);
    }
  }
  
  /**
   * 淘汰缓存（LRU策略）
   */
  private evict(): void {
    // 找到最近最少使用的条目
    let oldest: { key: string; entry: CacheEntry } | null = null;
    
    this.cache.forEach((entry, key) => {
      if (!oldest || entry.lastAccessTime < oldest.entry.lastAccessTime) {
        oldest = { key, entry };
      }
    });
    
    if (oldest) {
      this.cache.delete(oldest.key);
      this.stats.evictions++;
      console.debug(`[Cache] 淘汰: ${oldest.key}`);
    }
  }
  
  /**
   * 计算数据大小
   */
  private calculateSize(data: any): number {
    // 简化实现
    return JSON.stringify(data).length;
  }
  
  /**
   * 获取缓存统计
   */
  getStats(): CacheStats {
    const hitRate = this.stats.hits / (this.stats.hits + this.stats.misses);
    
    return {
      ...this.stats,
      hitRate: hitRate
    };
  }
}

// 缓存配置
interface CacheConfig {
  maxSize: number;           // 最大缓存条目数
  defaultTtl: number;        // 默认TTL（ms）
  cleanupInterval: number;   // 清理间隔（ms）
  autoLoad: boolean;         // 是否自动加载
  loader?: (key: string) => Promise<any>;  // 数据加载器
}

// 缓存条目
interface CacheEntry {
  key: string;
  data: any;
  createTime: number;
  lastAccessTime: number;
  accessCount: number;
  ttl: number;
  size: number;
}

// 缓存统计
interface CacheStats {
  hits: number;
  misses: number;
  evictions: number;
  hitRate?: number;
}

3.2 延迟优化：预测加载

/**
 * 预测加载服务
 * 基于用户行为预测并预加载数据
 */
export class PredictiveLoader {
  private behaviorHistory: UserBehavior[] = [];
  private predictionModel: PredictionModel | null = null;
  private dataCache: DistributedDataCache;
  
  constructor(dataCache: DistributedDataCache) {
    this.dataCache = dataCache;
  }
  
  /**
   * 记录用户行为
   */
  recordBehavior(behavior: UserBehavior): void {
    this.behaviorHistory.push(behavior);
    
    // 限制历史记录长度
    if (this.behaviorHistory.length > 1000) {
      this.behaviorHistory.shift();
    }
    
    // 触发预测
    this.predictAndPrefetch(behavior);
  }
  
  /**
   * 预测并预取
   */
  private async predictAndPrefetch(currentBehavior: UserBehavior): Promise<void> {
    // 预测下一步可能需要的数据
    const predictions = this.predict(currentBehavior);
    
    if (predictions.length === 0) {
      return;
    }
    
    // 过滤已缓存的数据
    const toPrefetch = predictions.filter(p => 
      !this.dataCache.get(p.key)
    );
    
    // 预取数据
    await this.dataCache.prefetch(toPrefetch.map(p => p.key));
    
    console.info(`[PredictiveLoader] 预取: ${toPrefetch.length}个`);
  }
  
  /**
   * 预测逻辑
   */
  private predict(current: UserBehavior): Prediction[] {
    const predictions: Prediction[] = [];
    
    // 基于当前行为的预测
    switch (current.action) {
      case 'view_device_list':
        // 用户可能查看设备详情
        predictions.push({
          key: `device_${current.targetId}_detail`,
          probability: 0.8
        });
        break;
        
      case 'start_exercise':
        // 用户可能需要运动数据
        predictions.push({
          key: `exercise_history_${current.userId}`,
          probability: 0.9
        });
        predictions.push({
          key: `exercise_stats_${current.userId}`,
          probability: 0.7
        });
        break;
        
      case 'view_stats':
        // 用户可能需要详细分析
        predictions.push({
          key: `analysis_${current.targetId}`,
          probability: 0.6
        });
        break;
    }
    
    // 基于历史行为的预测
    const recentHistory = this.behaviorHistory.slice(-10);
    const pattern = this.findPattern(recentHistory);
    
    if (pattern) {
      predictions.push(...pattern.predictions);
    }
    
    // 按概率排序
    predictions.sort((a, b) => b.probability - a.probability);
    
    // 返回概率最高的预测
    return predictions.slice(0, 5);
  }
  
  /**
   * 查找行为模式
   */
  private findPattern(history: UserBehavior[]): BehaviorPattern | null {
    // 简化实现：查找重复的行为序列
    if (history.length < 3) {
      return null;
    }
    
    // 检查是否有重复模式
    const lastThree = history.slice(-3).map(b => b.action).join(',');
    
    // 预定义的模式
    const patterns: Record<string, BehaviorPattern> = {
      'view_device_list,view_device_detail,start_exercise': {
        predictions: [
          { key: 'exercise_realtime_data', probability: 0.9 }
        ]
      }
    };
    
    return patterns[lastThree] || null;
  }
  
  /**
   * 训练预测模型
   */
  trainModel(): void {
    // 使用历史数据训练预测模型
    // 这里简化实现，实际可以使用机器学习算法
    console.info('[PredictiveLoader] 训练预测模型');
  }
}

// 用户行为
interface UserBehavior {
  action: string;
  targetId?: string;
  userId?: string;
  timestamp: number;
  context?: any;
}

// 预测结果
interface Prediction {
  key: string;
  probability: number;
}

// 行为模式
interface BehaviorPattern {
  predictions: Prediction[];
}

// 预测模型
interface PredictionModel {
  predict(behavior: UserBehavior): Prediction[];
}

3.3 带宽优化：数据压缩

import { zlib } from '@ohos.zlib';

/**
 * 数据压缩服务
 * 减少跨设备传输数据量
 */
export class DataCompressionService {
  private compressionThreshold: number = 1024;  // 1KB以上才压缩
  private compressionLevel: number = 6;         // 压缩级别（1-9）
  
  /**
   * 压缩数据
   */
  async compress(data: Uint8Array): Promise<CompressedData> {
    // 小数据不压缩
    if (data.length < this.compressionThreshold) {
      return {
        data: data,
        compressed: false,
        originalSize: data.length,
        compressedSize: data.length
      };
    }
    
    try {
      // 执行压缩
      const compressed = await zlib.compress(data, {
        level: this.compressionLevel
      });
      
      // 检查压缩效果
      if (compressed.length >= data.length) {
        // 压缩后更大，不使用压缩
        return {
          data: data,
          compressed: false,
          originalSize: data.length,
          compressedSize: data.length
        };
      }
      
      console.debug(`[Compression] 压缩: ${data.length} -> ${compressed.length}, ` +
                    `压缩率: ${((1 - compressed.length / data.length) * 100).toFixed(1)}%`);
      
      return {
        data: compressed,
        compressed: true,
        originalSize: data.length,
        compressedSize: compressed.length
      };
    } catch (error) {
      console.error(`[Compression] 压缩失败: ${JSON.stringify(error)}`);
      
      return {
        data: data,
        compressed: false,
        originalSize: data.length,
        compressedSize: data.length
      };
    }
  }
  
  /**
   * 解压数据
   */
  async decompress(data: CompressedData): Promise<Uint8Array> {
    if (!data.compressed) {
      return data.data;
    }
    
    try {
      const decompressed = await zlib.decompress(data.data);
      
      console.debug(`[Compression] 解压: ${data.compressedSize} -> ${data.originalSize}`);
      
      return decompressed;
    } catch (error) {
      console.error(`[Compression] 解压失败: ${JSON.stringify(error)}`);
      throw error;
    }
  }
  
  /**
   * 增量压缩
   * 只传输变化部分
   */
  async compressDelta(
    previous: Uint8Array,
    current: Uint8Array
  ): Promise<DeltaData> {
    // 计算差异
    const delta = this.calculateDelta(previous, current);
    
    // 压缩差异
    const compressedDelta = await this.compress(delta);
    
    return {
      delta: compressedDelta,
      baseSize: previous.length,
      targetSize: current.length
    };
  }
  
  /**
   * 应用增量
   */
  async applyDelta(
    base: Uint8Array,
    delta: DeltaData
  ): Promise<Uint8Array> {
    // 解压差异
    const deltaData = await this.decompress(delta.delta);
    
    // 应用差异
    return this.applyDeltaData(base, deltaData);
  }
  
  /**
   * 计算差异（简化实现）
   */
  private calculateDelta(previous: Uint8Array, current: Uint8Array): Uint8Array {
    // 实际实现可以使用更高效的差异算法
    // 如rsync算法、bsdiff等
    
    // 简化实现：返回完整数据
    return current;
  }
  
  /**
   * 应用差异数据
   */
  private applyDeltaData(base: Uint8Array, delta: Uint8Array): Uint8Array {
    // 简化实现
    return delta;
  }
}

// 压缩数据
interface CompressedData {
  data: Uint8Array;
  compressed: boolean;
  originalSize: number;
  compressedSize: number;
}

// 增量数据
interface DeltaData {
  delta: CompressedData;
  baseSize: number;
  targetSize: number;
}

3.4 带宽优化：增量同步

/**
 * 增量同步服务
 * 只同步变化的数据
 */
export class IncrementalSyncService {
  private dataVersion: Map<string, number> = new Map();
  private dataSnapshot: Map<string, any> = new Map();
  private compressionService: DataCompressionService;
  
  constructor(compressionService: DataCompressionService) {
    this.compressionService = compressionService;
  }
  
  /**
   * 同步数据（增量）
   */
  async syncData(
    key: string,
    data: any,
    targetDeviceId: string
  ): Promise<void> {
    // 获取当前版本
    const currentVersion = this.dataVersion.get(key) || 0;
    const newVersion = currentVersion + 1;
    
    // 获取快照
    const snapshot = this.dataSnapshot.get(key);
    
    // 计算增量
    const delta = this.calculateChange(snapshot, data);
    
    if (delta.isEmpty) {
      // 无变化，跳过同步
      console.debug(`[IncrementalSync] 无变化: ${key}`);
      return;
    }
    
    // 压缩增量
    const serializedDelta = this.serialize(delta);
    const compressed = await this.compressionService.compress(serializedDelta);
    
    // 发送增量
    await this.sendDelta(targetDeviceId, {
      key: key,
      version: newVersion,
      delta: compressed
    });
    
    // 更新本地状态
    this.dataVersion.set(key, newVersion);
    this.dataSnapshot.set(key, data);
    
    console.info(`[IncrementalSync] 同步: ${key}, 版本: ${newVersion}`);
  }
  
  /**
   * 接收增量并应用
   */
  async receiveDelta(deltaMessage: DeltaMessage): Promise<void> {
    const { key, version, delta } = deltaMessage;
    
    // 检查版本
    const localVersion = this.dataVersion.get(key) || 0;
    
    if (version <= localVersion) {
      // 旧版本，忽略
      console.debug(`[IncrementalSync] 忽略旧版本: ${key}, ${version}`);
      return;
    }
    
    // 解压增量
    const decompressed = await this.compressionService.decompress(delta);
    const change = this.deserialize(decompressed);
    
    // 应用增量
    const snapshot = this.dataSnapshot.get(key);
    const newData = this.applyChange(snapshot, change);
    
    // 更新本地状态
    this.dataVersion.set(key, version);
    this.dataSnapshot.set(key, newData);
    
    // 通知应用层
    this.notifyDataChanged(key, newData);
    
    console.info(`[IncrementalSync] 接收: ${key}, 版本: ${version}`);
  }
  
  /**
   * 计算变化
   */
  private calculateChange(previous: any, current: any): DataChange {
    if (!previous) {
      // 无快照，全量变化
      return {
        isEmpty: false,
        type: 'full',
        data: current
      };
    }
    
    // 计算差异
    const diff = this.diff(previous, current);
    
    return {
      isEmpty: Object.keys(diff).length === 0,
      type: 'partial',
      changes: diff
    };
  }
  
  /**
   * 应用变化
   */
  private applyChange(previous: any, change: DataChange): any {
    if (change.type === 'full') {
      return change.data;
    }
    
    // 应用部分变化
    const result = { ...previous };
    
    for (const [key, value] of Object.entries(change.changes)) {
      if (value === null) {
        delete result[key];
      } else {
        result[key] = value;
      }
    }
    
    return result;
  }
  
  /**
   * 计算差异（简化实现）
   */
  private diff(previous: any, current: any): any {
    const result: any = {};
    
    // 找出新增和修改的字段
    for (const key of Object.keys(current)) {
      if (previous[key] !== current[key]) {
        result[key] = current[key];
      }
    }
    
    // 找出删除的字段
    for (const key of Object.keys(previous)) {
      if (!(key in current)) {
        result[key] = null;
      }
    }
    
    return result;
  }
  
  /**
   * 发送增量（简化实现）
   */
  private async sendDelta(deviceId: string, message: DeltaMessage): Promise<void> {
    // 实际实现通过数据传输服务发送
    console.debug(`[IncrementalSync] 发送到: ${deviceId}`);
  }
  
  /**
   * 通知数据变化
   */
  private notifyDataChanged(key: string, data: any): void {
    // 实际实现通过事件总线通知
    console.debug(`[IncrementalSync] 数据变化: ${key}`);
  }
  
  // 序列化/反序列化（简化实现）
  private serialize(data: any): Uint8Array {
    return new TextEncoder().encode(JSON.stringify(data));
  }
  
  private deserialize(data: Uint8Array): any {
    return JSON.parse(new TextDecoder().decode(data));
  }
}

// 数据变化
interface DataChange {
  isEmpty: boolean;
  type: 'full' | 'partial';
  data?: any;
  changes?: any;
}

// 增量消息
interface DeltaMessage {
  key: string;
  version: number;
  delta: CompressedData;
}

3.5 性能监控服务

/**
 * 性能监控服务
 * 实时监控分布式性能指标
 */
export class PerformanceMonitorService {
  private metrics: PerformanceMetrics = {
    latency: { avg: 0, min: 0, max: 0, p50: 0, p95: 0, p99: 0 },
    throughput: { bytesPerSecond: 0, packetsPerSecond: 0, requestsPerSecond: 0 },
    errors: { lossRate: 0, errorRate: 0, retryCount: 0 },
    resources: { cpuUsage: 0, memoryUsage: 0, networkUsage: 0, powerConsumption: 0 }
  };
  
  private latencyHistory: number[] = [];
  private throughputHistory: ThroughputSample[] = [];
  private listeners: Set<PerformanceListener> = new Set();
  
  /**
   * 记录延迟
   */
  recordLatency(latency: number): void {
    this.latencyHistory.push(latency);
    
    // 限制历史长度
    if (this.latencyHistory.length > 1000) {
      this.latencyHistory.shift();
    }
    
    // 更新延迟统计
    this.updateLatencyMetrics();
    
    // 检查是否超过阈值
    if (latency > this.getLatencyThreshold()) {
      this.notifyHighLatency(latency);
    }
  }
  
  /**
   * 记录吞吐量
   */
  recordThroughput(bytes: number): void {
    const now = Date.now();
    
    this.throughputHistory.push({
      timestamp: now,
      bytes: bytes
    });
    
    // 限制历史长度
    if (this.throughputHistory.length > 1000) {
      this.throughputHistory.shift();
    }
    
    // 更新吞吐量统计
    this.updateThroughputMetrics();
  }
  
  /**
   * 记录错误
   */
  recordError(type: 'loss' | 'error' | 'retry'): void {
    switch (type) {
      case 'loss':
        this.metrics.errors.lossRate += 0.001;
        break;
      case 'error':
        this.metrics.errors.errorRate += 0.001;
        break;
      case 'retry':
        this.metrics.errors.retryCount++;
        break;
    }
    
    // 通知错误
    this.notifyError(type);
  }
  
  /**
   * 更新延迟统计
   */
  private updateLatencyMetrics(): void {
    const history = this.latencyHistory;
    
    if (history.length === 0) {
      return;
    }
    
    // 排序用于计算分位数
    const sorted = [...history].sort((a, b) => a - b);
    
    this.metrics.latency = {
      avg: history.reduce((a, b) => a + b, 0) / history.length,
      min: sorted[0],
      max: sorted[sorted.length - 1],
      p50: sorted[Math.floor(sorted.length * 0.5)],
      p95: sorted[Math.floor(sorted.length * 0.95)],
      p99: sorted[Math.floor(sorted.length * 0.99)]
    };
  }
  
  /**
   * 更新吞吐量统计
   */
  private updateThroughputMetrics(): void {
    const now = Date.now();
    const windowSize = 60000;  // 1分钟窗口
    
    // 过滤窗口内的样本
    const recentSamples = this.throughputHistory.filter(
      s => now - s.timestamp < windowSize
    );
    
    if (recentSamples.length === 0) {
      return;
    }
    
    // 计算吞吐量
    const totalBytes = recentSamples.reduce((sum, s) => sum + s.bytes, 0);
    const duration = (now - recentSamples[0].timestamp) / 1000;  // 秒
    
    this.metrics.throughput.bytesPerSecond = totalBytes / duration;
    this.metrics.throughput.packetsPerSecond = recentSamples.length / duration;
  }
  
  /**
   * 获取延迟阈值
   */
  private getLatencyThreshold(): number {
    // 动态阈值：基于历史数据的P95
    return this.metrics.latency.p95 * 2;
  }
  
  /**
   * 获取性能指标
   */
  getMetrics(): PerformanceMetrics {
    return { ...this.metrics };
  }
  
  /**
   * 添加监听器
   */
  addListener(listener: PerformanceListener): void {
    this.listeners.add(listener);
  }
  
  /**
   * 移除监听器
   */
  removeListener(listener: PerformanceListener): void {
    this.listeners.delete(listener);
  }
  
  /**
   * 通知高延迟
   */
  private notifyHighLatency(latency: number): void {
    this.listeners.forEach(listener => {
      listener.onHighLatency?.(latency);
    });
  }
  
  /**
   * 通知错误
   */
  private notifyError(type: string): void {
    this.listeners.forEach(listener => {
      listener.onError?.(type);
    });
  }
  
  /**
   * 生成性能报告
   */
  generateReport(): PerformanceReport {
    return {
      timestamp: Date.now(),
      metrics: this.getMetrics(),
      recommendations: this.generateRecommendations()
    };
  }
  
  /**
   * 生成优化建议
   */
  private generateRecommendations(): string[] {
    const recommendations: string[] = [];
    
    // 延迟建议
    if (this.metrics.latency.p95 > 100) {
      recommendations.push('延迟较高，建议启用本地缓存或预测加载');
    }
    
    // 吞吐量建议
    if (this.metrics.throughput.bytesPerSecond < 100000) {
      recommendations.push('吞吐量较低，建议启用数据压缩或增量同步');
    }
    
    // 错误率建议
    if (this.metrics.errors.lossRate > 0.01) {
      recommendations.push('丢包率较高，建议启用可靠传输或调整发送窗口');
    }
    
    return recommendations;
  }
}

// 吞吐量样本
interface ThroughputSample {
  timestamp: number;
  bytes: number;
}

// 性能监听器
interface PerformanceListener {
  onHighLatency?: (latency: number) => void;
  onError?: (type: string) => void;
}

// 性能报告
interface PerformanceReport {
  timestamp: number;
  metrics: PerformanceMetrics;
  recommendations: string[];
}

四、踩坑与注意事项

4.1 缓存相关

坑1：缓存一致性问题

多设备缓存可能导致数据不一致。

// ✅ 正确做法：实现缓存失效广播
class ConsistentCache extends DistributedDataCache {
  async invalidateGlobal(key: string): Promise<void> {
    // 本地失效
    await this.invalidate(key);
    
    // 广播失效消息
    await this.broadcastInvalidation(key);
  }
  
  private async broadcastInvalidation(key: string): Promise<void> {
    // 通过数据同步服务广播
    console.info(`广播缓存失效: ${key}`);
  }
}

坑2：缓存雪崩

大量缓存同时失效导致请求洪峰。

// ✅ 正确做法：实现TTL随机化
class AvalancheProofCache extends DistributedDataCache {
  async set<T>(key: string, data: T, ttl?: number): Promise<void> {
    // TTL随机化（±20%）
    const randomTtl = ttl || this.config.defaultTtl;
    const jitter = randomTtl * 0.2 * (Math.random() * 2 - 1);
    const finalTtl = randomTtl + jitter;
    
    await super.set(key, data, finalTtl);
  }
}

4.2 压缩相关

坑3：压缩效果不佳

某些数据类型压缩效果差甚至反向增长。

// ✅ 正确做法：智能选择压缩策略
class SmartCompression extends DataCompressionService {
  async compress(data: Uint8Array): Promise<CompressedData> {
    // 检测数据类型
    const dataType = this.detectDataType(data);
    
    // 根据数据类型选择压缩策略
    switch (dataType) {
      case 'text':
        // 文本数据，高压缩率
        return await this.compressWithLevel(data, 9);
        
      case 'binary':
        // 二进制数据，中等压缩
        return await this.compressWithLevel(data, 6);
        
      case 'media':
        // 媒体数据，已压缩，跳过
        return {
          data: data,
          compressed: false,
          originalSize: data.length,
          compressedSize: data.length
        };
        
      default:
        return await super.compress(data);
    }
  }
  
  private detectDataType(data: Uint8Array): string {
    // 简化实现
    return 'binary';
  }
}

4.3 监控相关

坑4：监控数据过多

监控数据本身占用大量资源。

// ✅ 正确做法：实现采样和聚合
class SampledMonitor extends PerformanceMonitorService {
  private sampleRate: number = 0.1;  // 10%采样率
  
  recordLatency(latency: number): void {
    // 采样
    if (Math.random() > this.sampleRate) {
      return;
    }
    
    super.recordLatency(latency);
  }
}

五、HarmonyOS 6适配指南

5.1 API变更

性能优化API增强：

// HarmonyOS 6新增性能优化框架
import { PerformanceOptimizer } from '@ohos.distributedHardware.performance';

const optimizer = PerformanceOptimizer.getInstance();

// 自动优化
await optimizer.enableAutoOptimization({
  latency: true,      // 延迟优化
  bandwidth: true,    // 带宽优化
  resources: true     // 资源优化
});

// 获取优化建议
const recommendations = await optimizer.getRecommendations();

5.2 行为变更

变更1：AI驱动优化

HarmonyOS 6引入AI驱动的性能优化。

// HarmonyOS 6新增AI优化
await optimizer.configureAIOptimization({
  enabled: true,
  learningEnabled: true,   // 启用学习
  adaptiveMode: true       // 自适应模式
});

变更2：实时性能分析

// HarmonyOS 6新增实时分析
const analysis = await optimizer.analyzeRealtime({
  duration: 60000,  // 分析最近1分钟
  metrics: ['latency', 'throughput', 'errors']
});

六、总结

分布式场景性能优化是保证用户体验的关键，通过延迟优化、带宽优化、资源优化等多维度策略，实现毫秒级响应和流畅体验。

核心要点回顾：

1. 延迟优化：本地缓存、预测加载、异步处理
2. 带宽优化：数据压缩、增量同步、智能路由
3. 性能监控：实时监控、阈值告警、优化建议
4. 踩坑处理：缓存一致性、压缩效果、监控开销