HarmonyOS开发分布式数据冲突处理

多设备协同就像多人协作编辑文档：A改了一处，B也改了同一处，谁的版本生效？冲突处理就是那个"和事佬"，让数据在矛盾中找到统一。

一、背景与动机：为什么冲突不可避免？

1.1 冲突产生的根源

在分布式系统中，冲突不是"会不会发生"的问题，而是"何时发生"的问题。根源在于：

网络延迟：

• 设备A修改数据，同步到设备B需要时间
• 在同步到达前，设备B也修改了同一数据
• 两个修改"撞车"，冲突产生

离线操作：

• 用户在飞机上修改了数据（离线）
• 同时家人在家里的设备上也修改了同一数据
• 两个设备重新上线后，数据冲突

并发写入：

• 多个设备同时修改同一数据
• 即使网络很快，也无法完全避免

sequenceDiagram
    participant DeviceA as 设备A
    participant Cloud as 云端/中继
    participant DeviceB as 设备B
    
    Note over DeviceA: 用户修改数据: value = "A"
    DeviceA->>Cloud: 同步: {key, value="A", time=10:00:00}
    
    Note over DeviceB: 用户修改数据: value = "B"
    DeviceB->>Cloud: 同步: {key, value="B", time=10:00:01}
    
    Cloud->>Cloud: 检测到冲突!
    Cloud->>Cloud: 执行冲突解决策略
    
    alt 时间戳优先
        Cloud->>DeviceA: 最终值: "B" (时间更晚)
        Cloud->>DeviceB: 最终值: "B"
    else 合并策略
        Cloud->>Cloud: 合并为: "A,B"
        Cloud->>DeviceA: 最终值: "A,B"
        Cloud->>DeviceB: 最终值: "A,B"
    end
    
    classDef primary fill:#4A90E2,stroke:#2E5C8A,stroke-width:2px,color:#fff
    classDef warning fill:#F5A623,stroke:#C17D10,stroke-width:2px,color:#fff
    classDef error fill:#D0021B,stroke:#9B0015,stroke-width:2px,color:#fff
    classDef info fill:#7ED321,stroke:#5BA318,stroke-width:2px,color:#fff
    
    class DeviceA,DeviceB primary
    class Cloud warning

1.2 冲突的类型

不同类型的数据，冲突表现不同：

值冲突：

• 两个设备修改了同一key的value
• 例如：设备A设置主题为"dark"，设备B设置为"light"

结构冲突：

• 一个设备修改了对象的部分字段
• 另一个设备修改了同一对象的其他字段
• 例如：设备A修改了用户的昵称，设备B修改了用户的头像

删除冲突：

• 一个设备删除了数据
• 另一个设备修改了同一数据
• 例如：设备A删除了收藏项，设备B修改了该项的备注

关系冲突：

• 多个数据之间存在关联关系
• 一个设备修改了关系的一方，另一个设备修改了另一方
• 例如：设备A修改了文章内容，设备B修改了文章的评论

二、核心原理：冲突解决策略

2.1 策略分类

HarmonyOS提供了多种冲突解决策略：

2.2 时间戳优先策略

最简单直接的策略：后修改者胜出。

interface TimestampEntry {
  key: string;
  value: any;
  timestamp: number;  // 修改时间戳
  deviceId: string;
}

// 冲突解决逻辑
function resolveByTimestamp(local: TimestampEntry, remote: TimestampEntry): TimestampEntry {
  if (local.timestamp > remote.timestamp) {
    return local;  // 本地更新，保留本地
  } else if (local.timestamp < remote.timestamp) {
    return remote;  // 远端更新，保留远端
  } else {
    // 时间戳相同，按设备ID排序（保证一致性）
    return local.deviceId > remote.deviceId ? local : remote;
  }
}

优点：简单、确定性强、无需用户介入
缺点：可能丢失较早但重要的修改

2.3 版本号优先策略

每次修改版本号自增，版本号大者胜出。

interface VersionedEntry {
  key: string;
  value: any;
  version: number;  // 版本号
  deviceId: string;
}

function resolveByVersion(local: VersionedEntry, remote: VersionedEntry): VersionedEntry {
  if (local.version > remote.version) {
    return local;
  } else if (local.version < remote.version) {
    return remote;
  } else {
    // 版本号相同但内容不同，说明发生了并发冲突
    // 需要其他策略辅助
    return resolveByDevicePriority(local, remote);
  }
}

优点：精确追踪修改次数
缺点：需要维护版本号，增加复杂度

2.4 字段级合并策略

对于结构化数据，可以按字段合并，避免全量覆盖。

interface User {
  name: string;
  avatar: string;
  age: number;
  lastModified: {
    name: number;
    avatar: number;
    age: number;
  };
}

function mergeByField(local: User, remote: User): User {
  const result: User = {
    name: '',
    avatar: '',
    age: 0,
    lastModified: {
      name: 0,
      avatar: 0,
      age: 0
    }
  };
  
  // 每个字段独立判断
  if (local.lastModified.name > remote.lastModified.name) {
    result.name = local.name;
    result.lastModified.name = local.lastModified.name;
  } else {
    result.name = remote.name;
    result.lastModified.name = remote.lastModified.name;
  }
  
  if (local.lastModified.avatar > remote.lastModified.avatar) {
    result.avatar = local.avatar;
    result.lastModified.avatar = local.lastModified.avatar;
  } else {
    result.avatar = remote.avatar;
    result.lastModified.avatar = remote.lastModified.avatar;
  }
  
  if (local.lastModified.age > remote.lastModified.age) {
    result.age = local.age;
    result.lastModified.age = local.lastModified.age;
  } else {
    result.age = remote.age;
    result.lastModified.age = remote.lastModified.age;
  }
  
  return result;
}

优点：最大程度保留各方修改
缺点：需要数据结构支持，实现复杂

2.5 自定义策略

HarmonyOS允许开发者实现自定义冲突解决逻辑。

interface ConflictResolver {
  resolve(local: DataEntry, remote: DataEntry): DataEntry;
}

interface DataEntry {
  key: string;
  value: any;
  timestamp: number;
  deviceId: string;
  metadata?: Map<string, any>;  // 自定义元数据
}

三、代码实战：实现冲突解决策略

3.1 基础示例：时间戳优先策略

import distributedData from '@ohos.data.distributedData';

/**
 * 时间戳优先冲突解决器
 * 最简单直接的策略实现
 */
export class TimestampConflictResolver implements distributedData.ConflictResolver {
  /**
   * 解决冲突
   * @param local 本地数据
   * @param remote 远端数据
   * @returns 胜出的数据
   */
  resolve(local: distributedData.Entry, remote: distributedData.Entry): distributedData.Entry {
    // 解析数据中的时间戳
    const localData = this.parseEntry(local);
    const remoteData = this.parseEntry(remote);
    
    // 比较时间戳
    if (localData.timestamp > remoteData.timestamp) {
      console.info(`[ConflictResolver] 本地胜出: ${local.key}, 时间差 ${localData.timestamp - remoteData.timestamp}ms`);
      return local;
    } else if (localData.timestamp < remoteData.timestamp) {
      console.info(`[ConflictResolver] 远端胜出: ${remote.key}, 时间差 ${remoteData.timestamp - localData.timestamp}ms`);
      return remote;
    } else {
      // 时间戳相同，使用设备ID作为决胜条件
      const winner = localData.deviceId > remoteData.deviceId ? local : remote;
      console.info(`[ConflictResolver] 时间戳相同，设备ID决胜: ${winner.key}`);
      return winner;
    }
  }
  
  /**
   * 解析数据条目
   * 提取时间戳和设备ID
   */
  private parseEntry(entry: distributedData.Entry): { timestamp: number; deviceId: string } {
    try {
      const value = JSON.parse(entry.value as string);
      return {
        timestamp: value.timestamp || 0,
        deviceId: value.deviceId || ''
      };
    } catch {
      // 解析失败，返回默认值
      return { timestamp: 0, deviceId: '' };
    }
  }
}

/**
 * 使用时间戳优先策略的KV存储
 */
export class TimestampPriorityStore {
  private kvStore: distributedData.KVStore | null = null;
  
  /**
   * 初始化存储
   * 配置时间戳优先冲突解决策略
   */
  async init(): Promise<void> {
    const kvManager = distributedData.createKVManager({
      bundleName: 'com.example.myapp',
      userId: 0
    });
    
    const options: distributedData.Options = {
      createIfMissing: true,
      autoSync: true,
      kvStoreType: distributedData.KVStoreType.DEVICE_COLLABORATION,
      securityLevel: distributedData.SecurityLevel.S1,
      
      // 配置冲突解决策略
      conflictResolver: new TimestampConflictResolver()
    };
    
    this.kvStore = await kvManager.getKVStore('timestamp_priority_store', options);
    console.info('[TimestampStore] 时间戳优先策略已启用');
  }
  
  /**
   * 写入数据
   * 自动附加时间戳和设备ID
   */
  async put(key: string, value: any): Promise<void> {
    if (!this.kvStore) {
      throw new Error('KV存储未初始化');
    }
    
    // 包装数据，附加元信息
    const wrappedValue = {
      data: value,
      timestamp: Date.now(),
      deviceId: await this.getDeviceId()
    };
    
    await this.kvStore.put(key, JSON.stringify(wrappedValue));
    console.info(`[TimestampStore] 数据已写入: ${key}`);
  }
  
  /**
   * 读取数据
   * 解包返回原始数据
   */
  async get(key: string): Promise<any> {
    if (!this.kvStore) {
      throw new Error('KV存储未初始化');
    }
    
    const value = await this.kvStore.get(key);
    const wrapped = JSON.parse(value as string);
    return wrapped.data;
  }
  
  /**
   * 获取当前设备ID
   */
  private async getDeviceId(): Promise<string> {
    // 实际项目中通过DeviceManager获取
    return 'device_' + Date.now();
  }
}

3.2 进阶示例：字段级合并策略

import distributedData from '@ohos.data.distributedData';

/**
 * 字段级合并冲突解决器
 * 适用于结构化数据的细粒度合并
 */
export class FieldMergeConflictResolver implements distributedData.ConflictResolver {
  /**
   * 解决冲突
   * 按字段级别合并，保留各方修改
   */
  resolve(local: distributedData.Entry, remote: distributedData.Entry): distributedData.Entry {
    try {
      const localObj = JSON.parse(local.value as string);
      const remoteObj = JSON.parse(remote.value as string);
      
      // 执行字段级合并
      const merged = this.mergeObjects(localObj, remoteObj);
      
      // 返回合并结果
      const result: distributedData.Entry = {
        key: local.key,
        value: JSON.stringify(merged)
      };
      
      console.info(`[FieldMergeResolver] 字段级合并完成: ${local.key}`);
      return result;
    } catch (error) {
      // 合并失败，退化为时间戳优先
      console.warn(`[FieldMergeResolver] 合并失败，退化为时间戳优先: ${error}`);
      return this.fallbackToTimestamp(local, remote);
    }
  }
  
  /**
   * 合并两个对象
   * 对每个字段独立判断
   */
  private mergeObjects(local: any, remote: any): any {
    // 获取所有字段
    const allKeys = new Set([
      ...Object.keys(local),
      ...Object.keys(remote)
    ]);
    
    const result: any = {};
    
    for (const key of allKeys) {
      // 跳过元数据字段
      if (key === '_metadata') continue;
      
      const localValue = local[key];
      const remoteValue = remote[key];
      
      // 字段只存在于一方
      if (localValue === undefined) {
        result[key] = remoteValue;
        continue;
      }
      if (remoteValue === undefined) {
        result[key] = localValue;
        continue;
      }
      
      // 字段都存在，需要判断
      result[key] = this.resolveField(key, localValue, remoteValue, local, remote);
    }
    
    // 更新元数据
    result._metadata = {
      lastMerged: Date.now(),
      mergeType: 'field-level'
    };
    
    return result;
  }
  
  /**
   * 解决单个字段的冲突
   */
  private resolveField(field: string, localValue: any, remoteValue: any, 
                       localObj: any, remoteObj: any): any {
    // 如果值相同，无需处理
    if (localValue === remoteValue) {
      return localValue;
    }
    
    // 获取字段的修改时间（如果有）
    const localMeta = localObj._metadata?.fields?.[field];
    const remoteMeta = remoteObj._metadata?.fields?.[field];
    
    if (localMeta && remoteMeta) {
      // 都有修改时间，按时间戳判断
      if (localMeta.timestamp > remoteMeta.timestamp) {
        return localValue;
      } else {
        return remoteValue;
      }
    } else if (localMeta) {
      // 只有本地有修改时间
      return localValue;
    } else if (remoteMeta) {
      // 只有远端有修改时间
      return remoteValue;
    } else {
      // 都没有修改时间，按对象整体时间戳判断
      const localTime = localObj._metadata?.timestamp || 0;
      const remoteTime = remoteObj._metadata?.timestamp || 0;
      return localTime > remoteTime ? localValue : remoteValue;
    }
  }
  
  /**
   * 退化为时间戳优先策略
   */
  private fallbackToTimestamp(local: distributedData.Entry, remote: distributedData.Entry): distributedData.Entry {
    const localTime = this.extractTimestamp(local);
    const remoteTime = this.extractTimestamp(remote);
    return localTime > remoteTime ? local : remote;
  }
  
  private extractTimestamp(entry: distributedData.Entry): number {
    try {
      const obj = JSON.parse(entry.value as string);
      return obj._metadata?.timestamp || 0;
    } catch {
      return 0;
    }
  }
}

/**
 * 字段级合并数据管理器
 * 自动追踪每个字段的修改时间
 */
export class FieldMergeDataManager {
  private kvStore: distributedData.KVStore | null = null;
  
  async init(): Promise<void> {
    const kvManager = distributedData.createKVManager({
      bundleName: 'com.example.myapp',
      userId: 0
    });
    
    const options: distributedData.Options = {
      createIfMissing: true,
      autoSync: true,
      kvStoreType: distributedData.KVStoreType.DEVICE_COLLABORATION,
      securityLevel: distributedData.SecurityLevel.S1,
      conflictResolver: new FieldMergeConflictResolver()
    };
    
    this.kvStore = await kvManager.getKVStore('field_merge_store', options);
  }
  
  /**
   * 更新单个字段
   * 自动追踪字段级修改时间
   */
  async updateField(key: string, field: string, value: any): Promise<void> {
    if (!this.kvStore) {
      throw new Error('KV存储未初始化');
    }
    
    // 读取现有数据
    let obj: any = {};
    try {
      const existing = await this.kvStore.get(key);
      obj = JSON.parse(existing as string);
    } catch {
      // 数据不存在，使用空对象
    }
    
    // 更新字段
    obj[field] = value;
    
    // 更新元数据
    if (!obj._metadata) {
      obj._metadata = { fields: {} };
    }
    if (!obj._metadata.fields) {
      obj._metadata.fields = {};
    }
    
    obj._metadata.fields[field] = {
      timestamp: Date.now(),
      deviceId: await this.getDeviceId()
    };
    obj._metadata.timestamp = Date.now();
    
    // 写入
    await this.kvStore.put(key, JSON.stringify(obj));
    console.info(`[FieldMergeManager] 字段已更新: ${key}.${field}`);
  }
  
  private async getDeviceId(): Promise<string> {
    return 'device_' + Date.now();
  }
}

3.3 高级示例：自定义策略与用户介入

import distributedData from '@ohos.data.distributedData';

/**
 * 冲突类型枚举
 */
enum ConflictType {
  NO_CONFLICT = 'no_conflict',
  VALUE_CONFLICT = 'value_conflict',
  DELETE_CONFLICT = 'delete_conflict',
  STRUCTURE_CONFLICT = 'structure_conflict'
}

/**
 * 冲突记录
 */
interface ConflictRecord {
  id: string;
  key: string;
  localValue: any;
  remoteValue: any;
  localMeta: DataMetadata;
  remoteMeta: DataMetadata;
  type: ConflictType;
  timestamp: number;
  resolved: boolean;
  resolution?: 'local' | 'remote' | 'merged';
}

interface DataMetadata {
  timestamp: number;
  deviceId: string;
  version: number;
}

/**
 * 智能冲突解决器
 * 支持自动解决和用户介入
 */
export class SmartConflictResolver implements distributedData.ConflictResolver {
  private conflictQueue: ConflictRecord[] = [];
  private autoResolveEnabled: boolean = true;
  
  /**
   * 解决冲突
   */
  resolve(local: distributedData.Entry, remote: distributedData.Entry): distributedData.Entry {
    // 检测冲突类型
    const conflictType = this.detectConflictType(local, remote);
    
    if (conflictType === ConflictType.NO_CONFLICT) {
      return local;
    }
    
    // 尝试自动解决
    if (this.autoResolveEnabled) {
      const autoResolved = this.tryAutoResolve(local, remote, conflictType);
      if (autoResolved) {
        return autoResolved;
      }
    }
    
    // 无法自动解决，记录冲突等待用户介入
    const conflict = this.createConflictRecord(local, remote, conflictType);
    this.conflictQueue.push(conflict);
    
    // 暂时返回本地版本（或远端版本，取决于策略）
    console.warn(`[SmartResolver] 冲突已记录，等待用户介入: ${local.key}`);
    return local;
  }
  
  /**
   * 检测冲突类型
   */
  private detectConflictType(local: distributedData.Entry, remote: distributedData.Entry): ConflictType {
    // 检查是否为删除冲突
    const localDeleted = local.value === null || local.value === undefined;
    const remoteDeleted = remote.value === null || remote.value === undefined;
    
    if (localDeleted && !remoteDeleted) {
      return ConflictType.DELETE_CONFLICT;  // 本地删除，远端修改
    }
    if (!localDeleted && remoteDeleted) {
      return ConflictType.DELETE_CONFLICT;  // 本地修改，远端删除
    }
    
    // 检查是否为值冲突
    if (local.value !== remote.value) {
      // 进一步检查是否为结构化数据
      try {
        const localObj = JSON.parse(local.value as string);
        const remoteObj = JSON.parse(remote.value as string);
        
        if (typeof localObj === 'object' && typeof remoteObj === 'object') {
          return ConflictType.STRUCTURE_CONFLICT;
        }
      } catch {
        // 不是JSON，是简单值冲突
      }
      
      return ConflictType.VALUE_CONFLICT;
    }
    
    return ConflictType.NO_CONFLICT;
  }
  
  /**
   * 尝试自动解决冲突
   */
  private tryAutoResolve(local: distributedData.Entry, remote: distributedData.Entry, 
                         type: ConflictType): distributedData.Entry | null {
    switch (type) {
      case ConflictType.VALUE_CONFLICT:
        // 简单值冲突：时间戳优先
        return this.resolveByTimestamp(local, remote);
        
      case ConflictType.STRUCTURE_CONFLICT:
        // 结构化数据：尝试字段级合并
        return this.tryFieldMerge(local, remote);
        
      case ConflictType.DELETE_CONFLICT:
        // 删除冲突：保留修改（不删除）
        const localDeleted = local.value === null || local.value === undefined;
        return localDeleted ? remote : local;
        
      default:
        return null;
    }
  }
  
  /**
   * 时间戳优先解决
   */
  private resolveByTimestamp(local: distributedData.Entry, remote: distributedData.Entry): distributedData.Entry {
    const localTime = this.extractTimestamp(local);
    const remoteTime = this.extractTimestamp(remote);
    return localTime > remoteTime ? local : remote;
  }
  
  /**
   * 尝试字段级合并
   */
  private tryFieldMerge(local: distributedData.Entry, remote: distributedData.Entry): distributedData.Entry | null {
    try {
      const localObj = JSON.parse(local.value as string);
      const remoteObj = JSON.parse(remote.value as string);
      
      // 检查是否有重叠修改的字段
      const conflictFields = this.findConflictFields(localObj, remoteObj);
      
      if (conflictFields.length === 0) {
        // 无重叠修改，可以安全合并
        const merged = { ...remoteObj, ...localObj };
        return {
          key: local.key,
          value: JSON.stringify(merged)
        };
      }
      
      // 有重叠修改，无法自动合并
      return null;
    } catch {
      return null;
    }
  }
  
  /**
   * 查找冲突字段
   */
  private findConflictFields(local: any, remote: any): string[] {
    const conflicts: string[] = [];
    
    for (const key of Object.keys(local)) {
      if (key === '_metadata') continue;
      
      if (remote[key] !== undefined && local[key] !== remote[key]) {
        conflicts.push(key);
      }
    }
    
    return conflicts;
  }
  
  /**
   * 创建冲突记录
   */
  private createConflictRecord(local: distributedData.Entry, remote: distributedData.Entry, 
                               type: ConflictType): ConflictRecord {
    return {
      id: `conflict_${Date.now()}_${Math.random()}`,
      key: local.key,
      localValue: local.value,
      remoteValue: remote.value,
      localMeta: this.extractMetadata(local),
      remoteMeta: this.extractMetadata(remote),
      type,
      timestamp: Date.now(),
      resolved: false
    };
  }
  
  /**
   * 获取待解决的冲突列表
   */
  getPendingConflicts(): ConflictRecord[] {
    return this.conflictQueue.filter(c => !c.resolved);
  }
  
  /**
   * 用户解决冲突
   */
  async resolveConflict(conflictId: string, resolution: 'local' | 'remote' | 'merged', 
                        mergedValue?: any): Promise<void> {
    const conflict = this.conflictQueue.find(c => c.id === conflictId);
    if (!conflict) {
      throw new Error(`冲突记录不存在: ${conflictId}`);
    }
    
    conflict.resolved = true;
    conflict.resolution = resolution;
    
    // 根据用户选择应用解决方案
    let finalValue: any;
    switch (resolution) {
      case 'local':
        finalValue = conflict.localValue;
        break;
      case 'remote':
        finalValue = conflict.remoteValue;
        break;
      case 'merged':
        finalValue = mergedValue;
        break;
    }
    
    // 写入最终值（需要外部调用）
    console.info(`[SmartResolver] 冲突已解决: ${conflict.key}, 策略: ${resolution}`);
  }
  
  private extractTimestamp(entry: distributedData.Entry): number {
    try {
      const obj = JSON.parse(entry.value as string);
      return obj._metadata?.timestamp || 0;
    } catch {
      return 0;
    }
  }
  
  private extractMetadata(entry: distributedData.Entry): DataMetadata {
    try {
      const obj = JSON.parse(entry.value as string);
      return obj._metadata || { timestamp: 0, deviceId: '', version: 0 };
    } catch {
      return { timestamp: 0, deviceId: '', version: 0 };
    }
  }
}

四、踩坑与注意事项

4.1 时间戳同步问题

问题：不同设备的时钟可能不同步，导致时间戳比较失效。

解决方案：使用逻辑时钟或向量时钟

/**
 * 向量时钟实现
 * 解决物理时钟不同步问题
 */
export class VectorClock {
  private clock: Map<string, number> = new Map();
  private deviceId: string;
  
  constructor(deviceId: string) {
    this.deviceId = deviceId;
    this.clock.set(deviceId, 0);
  }
  
  /**
   * 本地事件：递增自己的时钟
   */
  increment(): void {
    const current = this.clock.get(this.deviceId) || 0;
    this.clock.set(this.deviceId, current + 1);
  }
  
  /**
   * 接收远端消息：合并时钟
   */
  merge(remoteClock: VectorClock): void {
    for (const [deviceId, time] of remoteClock.clock) {
      const localTime = this.clock.get(deviceId) || 0;
      this.clock.set(deviceId, Math.max(localTime, time));
    }
    
    // 递增自己的时钟
    this.increment();
  }
  
  /**
   * 比较两个向量时钟
   * 返回: -1(小于), 0(并发), 1(大于)
   */
  compare(other: VectorClock): number {
    let allGreaterOrEqual = true;
    let allLessOrEqual = true;
    let atLeastOneDifferent = false;
    
    const allDeviceIds = new Set([
      ...this.clock.keys(),
      ...other.clock.keys()
    ]);
    
    for (const deviceId of allDeviceIds) {
      const thisTime = this.clock.get(deviceId) || 0;
      const otherTime = other.clock.get(deviceId) || 0;
      
      if (thisTime > otherTime) {
        allLessOrEqual = false;
        atLeastOneDifferent = true;
      } else if (thisTime < otherTime) {
        allGreaterOrEqual = false;
        atLeastOneDifferent = true;
      }
    }
    
    if (allGreaterOrEqual && atLeastOneDifferent) return 1;
    if (allLessOrEqual && atLeastOneDifferent) return -1;
    return 0;  // 并发
  }
  
  /**
   * 序列化
   */
  serialize(): string {
    const obj: Record<string, number> = {};
    for (const [key, value] of this.clock) {
      obj[key] = value;
    }
    return JSON.stringify(obj);
  }
  
  /**
   * 反序列化
   */
  static deserialize(data: string, deviceId: string): VectorClock {
    const vc = new VectorClock(deviceId);
    const obj = JSON.parse(data);
    for (const [key, value] of Object.entries(obj)) {
      vc.clock.set(key, value as number);
    }
    return vc;
  }
}

4.2 删除冲突的特殊处理

问题：一方删除、一方修改，如何处理？

解决方案：软删除 + 版本控制

/**
 * 软删除数据结构
 */
interface SoftDeletableData {
  value: any;
  deleted: boolean;        // 是否已删除
  deleteTime?: number;     // 删除时间
  modifyTime: number;      // 最后修改时间
  version: number;         // 版本号
}

/**
 * 软删除冲突解决器
 */
export class SoftDeleteConflictResolver implements distributedData.ConflictResolver {
  resolve(local: distributedData.Entry, remote: distributedData.Entry): distributedData.Entry {
    const localData: SoftDeletableData = JSON.parse(local.value as string);
    const remoteData: SoftDeletableData = JSON.parse(remote.value as string);
    
    // 情况1：双方都删除
    if (localData.deleted && remoteData.deleted) {
      return local.modifyTime > remote.modifyTime ? local : remote;
    }
    
    // 情况2：本地删除，远端修改
    if (localData.deleted && !remoteData.deleted) {
      // 判断删除和修改的时间顺序
      if (localData.deleteTime! > remoteData.modifyTime) {
        // 删除在后，保留删除
        return local;
      } else {
        // 修改在后，保留修改（相当于撤销删除）
        return remote;
      }
    }
    
    // 情况3：本地修改，远端删除
    if (!localData.deleted && remoteData.deleted) {
      if (remoteData.deleteTime! > localData.modifyTime) {
        return remote;
      } else {
        return local;
      }
    }
    
    // 情况4：双方都修改
    return localData.modifyTime > remoteData.modifyTime ? local : remote;
  }
}

4.3 冲突风暴

问题：大量数据同时冲突，导致系统卡顿。

解决方案：批量处理 + 异步队列

/**
 * 冲突批量处理器
 */
export class ConflictBatchProcessor {
  private conflictQueue: ConflictRecord[] = [];
  private processing: boolean = false;
  private readonly BATCH_SIZE = 50;
  
  /**
   * 添加冲突到队列
   */
  addConflict(conflict: ConflictRecord): void {
    this.conflictQueue.push(conflict);
    
    // 触发异步处理
    if (!this.processing) {
      this.processBatch();
    }
  }
  
  /**
   * 批量处理冲突
   */
  private async processBatch(): Promise<void> {
    this.processing = true;
    
    while (this.conflictQueue.length > 0) {
      // 取出一批冲突
      const batch = this.conflictQueue.splice(0, this.BATCH_SIZE);
      
      // 并行处理
      await Promise.all(batch.map(conflict => this.resolveConflict(conflict)));
      
      // 让出执行权，避免阻塞
      await this.sleep(10);
    }
    
    this.processing = false;
  }
  
  private async resolveConflict(conflict: ConflictRecord): Promise<void> {
    // 冲突解决逻辑
  }
  
  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

五、HarmonyOS 6适配指南

5.1 API变更

5.1.1 冲突解决器接口增强

// HarmonyOS 5.0
interface ConflictResolver {
  resolve(local: Entry, remote: Entry): Entry;
}

// HarmonyOS 6 - 增强的冲突解决器
interface EnhancedConflictResolver {
  // 基础解决方法
  resolve(local: Entry, remote: Entry): Entry;
  
  // HarmonyOS 6新增：批量解决
  resolveBatch(conflicts: ConflictPair[]): ResolvedEntry[];
  
  // HarmonyOS 6新增：冲突预检测
  predictConflict(local: Entry, remote: Entry): ConflictPrediction;
  
  // HarmonyOS 6新增：冲突历史查询
  getConflictHistory(key: string): ConflictHistory[];
}

interface ConflictPair {
  local: Entry;
  remote: Entry;
}

interface ResolvedEntry {
  key: string;
  value: any;
  resolution: 'local' | 'remote' | 'merged';
}

interface ConflictPrediction {
  hasConflict: boolean;
  conflictType: ConflictType;
  suggestedResolution: 'local' | 'remote' | 'merged';
  confidence: number;  // 0-1
}

interface ConflictHistory {
  timestamp: number;
  localValue: any;
  remoteValue: any;
  resolution: string;
}

5.1.2 冲突统计API

// HarmonyOS 6新增：冲突统计
const stats = await kvStore.getConflictStats();

console.info(`总冲突数: ${stats.totalConflicts}`);
console.info(`自动解决数: ${stats.autoResolved}`);
console.info(`手动解决数: ${stats.manualResolved}`);
console.info(`待解决数: ${stats.pending}`);
console.info(`解决率: ${stats.resolutionRate}%`);

5.2 行为变更

5.2.1 默认冲突策略

// HarmonyOS 5.0: 默认使用时间戳优先
// HarmonyOS 6: 默认使用智能策略（根据数据类型自动选择）

// 如需使用传统策略，需显式配置
const options: distributedData.Options = {
  createIfMissing: true,
  autoSync: true,
  kvStoreType: distributedData.KVStoreType.DEVICE_COLLABORATION,
  securityLevel: distributedData.SecurityLevel.S1,
  
  // HarmonyOS 6新增：显式指定默认策略
  defaultConflictStrategy: 'timestamp',  // 或 'version' 或 'field-merge'
  
  // 或使用自定义策略
  conflictResolver: new CustomConflictResolver()
};

5.3 性能优化

/**
 * HarmonyOS 6冲突处理性能优化
 */
export class HarmonyOS6ConflictOptimization {
  /**
   * 推荐配置
   */
  getOptimizedOptions(): distributedData.Options {
    return {
      createIfMissing: true,
      autoSync: true,
      kvStoreType: distributedData.KVStoreType.DEVICE_COLLABORATION,
      securityLevel: distributedData.SecurityLevel.S1,
      
      // HarmonyOS 6性能优化配置
      defaultConflictStrategy: 'smart',  // 智能策略
      
      // 启用冲突预测
      conflictPrediction: true,
      
      // 批量解决配置
      batchResolve: true,
      batchResolveSize: 100,
      
      // 冲突历史记录
      conflictHistory: true,
      maxConflictHistory: 1000,  // 最多保留1000条历史
      
      // 冲突统计
      conflictStats: true
    };
  }
}

六、总结

冲突处理是分布式系统的核心难题，也是HarmonyOS分布式能力的试金石。通过本文的深度解析，我们掌握了：

核心要点：

1. 冲突根源：网络延迟、离线操作、并发写入是冲突的三大根源
2. 策略分类：自动策略（时间戳、版本号）、半自动策略（字段合并）、手动策略（用户介入）
3. 实战技巧：从简单的时间戳优先到复杂的智能策略，满足不同场景需求
4. 避坑指南：时间戳同步、删除冲突、冲突风暴等常见问题及解决方案
5. 版本适配：HarmonyOS 6的API增强、智能策略、性能优化

最佳实践：

• 简单数据：时间戳优先，简单高效
• 结构化数据：字段级合并，保留各方修改
• 关键数据：用户介入，确保正确性
• 大批量数据：批量处理，避免性能问题

决策树：

冲突发生 → 数据类型？
├─ 简单值 → 时间戳优先
├─ 结构化 → 字段级合并
│          ├─ 无重叠 → 自动合并
│          └─ 有重叠 → 用户介入
├─ 删除冲突 → 软删除策略
└─ 关键数据 → 用户确认

掌握冲突处理，你的分布式应用才能在数据矛盾中找到统一，真正实现多设备的无缝协同。