代码之恋（第十五篇：分布式心跳与网络延迟）

南国的早晨，李磊站在新租的公寓窗前，看着陌生的城市。来小渔村一周，升职带来的兴奋已褪去，剩下的是对江城的思念。他打开电脑，屏幕上显示着与艾丽的视频通话窗口------这是他们每晚的"同步时间"。

// Collaboration_v3.0 - 分布式心跳系统
// 重构：从v1.0的简单WebSocket到v3.0的分布式心跳检测

class DistributedHeartbeat {
  constructor(config) {
    this.nodes = new Map(); // 节点映射：{nodeId: {lastPing, status, location}}
    this.heartbeatInterval = config.interval || 30000; // 30秒心跳
    this.timeoutThreshold = config.timeout || 120000; // 2分钟超时
    this.syncQueue = []; // 同步队列
    this.reconnectStrategy = {
      maxRetries: 5,
      backoff: 'exponential', // 指数退避
      baseDelay: 1000
    };
  }

  // 注册节点（南国-蓟都）
  registerNode(nodeId, location, metadata = {}) {
    this.nodes.set(nodeId, {
      nodeId,
      location,
      lastPing: Date.now(),
      status: 'online',
      metadata,
      latency: 0,
      packetLoss: 0
    });
    console.log(`✅ 节点注册: ${nodeId} @ ${location}`);
  }

  // 心跳检测（模拟网络延迟）
  async ping(nodeId) {
    const node = this.nodes.get(nodeId);
    if (!node) return null;

    const startTime = Date.now();
    try {
      // 模拟网络延迟（南国-蓟都：约50-200ms）
      const simulatedLatency = 50 + Math.random() * 150;
      await this.delay(simulatedLatency);
      
      const latency = Date.now() - startTime;
      node.lastPing = Date.now();
      node.latency = latency;
      node.status = 'online';
      
      return { success: true, latency };
    } catch (error) {
      node.packetLoss++;
      node.status = 'unstable';
      return { success: false, error: error.message };
    }
  }

  // 同步数据（消息、状态、文件）
  async syncData(nodeId, data, priority = 'normal') {
    const node = this.nodes.get(nodeId);
    if (!node || node.status !== 'online') {
      // 离线时加入队列
      this.syncQueue.push({ nodeId, data, priority, timestamp: Date.now() });
      return { queued: true };
    }

    try {
      // 根据优先级调整传输策略
      const strategy = this.getSyncStrategy(priority);
      const result = await this.transferData(nodeId, data, strategy);
      
      // 记录同步日志
      this.logSync(nodeId, data, result);
      return result;
    } catch (error) {
      // 失败重试
      return await this.retrySync(nodeId, data);
    }
  }

  // 获取同步策略
  getSyncStrategy(priority) {
    const strategies = {
      critical: { compression: true, encryption: true, retries: 5 },
      high: { compression: true, retries: 3 },
      normal: { compression: false, retries: 2 },
      low: { retries: 1 }
    };
    return strategies[priority] || strategies.normal;
  }

  // 延迟函数
  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  // 传输数据（模拟）
  async transferData(nodeId, data, strategy) {
    await this.delay(strategy.latency || 100);
    return { success: true, transferred: data };
  }

  // 重试同步
  async retrySync(nodeId, data, attempt = 0) {
    if (attempt >= this.reconnectStrategy.maxRetries) {
      return { success: false, error: 'Max retries exceeded' };
    }

    const delay = this.calculateBackoff(attempt);
    await this.delay(delay);
    
    return await this.syncData(nodeId, data);
  }

  // 指数退避计算
  calculateBackoff(attempt) {
    const { baseDelay, backoff } = this.reconnectStrategy;
    if (backoff === 'exponential') {
      return baseDelay * Math.pow(2, attempt);
    }
    return baseDelay * (attempt + 1);
  }

  // 记录同步日志
  logSync(nodeId, data, result) {
    console.log(`📤 同步到 ${nodeId}:`, {
      type: data.type,
      size: JSON.stringify(data).length,
      latency: result.latency || 0,
      success: result.success
    });
  }

  // 检查节点健康状态
  checkNodeHealth() {
    const now = Date.now();
    for (const [nodeId, node] of this.nodes) {
      const timeSinceLastPing = now - node.lastPing;
      
      if (timeSinceLastPing > this.timeoutThreshold) {
        node.status = 'offline';
        console.warn(`⚠️ 节点 ${nodeId} 超时，最后心跳: ${timeSinceLastPing}ms前`);
      } else if (node.packetLoss > 3) {
        node.status = 'unstable';
        console.warn(`⚠️ 节点 ${nodeId} 不稳定，丢包率: ${node.packetLoss}`);
      }
    }
  }

  // 启动心跳监控
  startMonitoring() {
    setInterval(() => {
      for (const nodeId of this.nodes.keys()) {
        this.ping(nodeId);
      }
      this.checkNodeHealth();
    }, this.heartbeatInterval);
  }
}

// 使用示例
const heartbeat = new DistributedHeartbeat({
  interval: 30000,
  timeout: 120000
});

// 注册两个节点
heartbeat.registerNode('shenzhen', '南国', { user: 'LiLei', timezone: 'UTC+8' });
heartbeat.registerNode('beijing', '蓟都', { user: 'AiLi', timezone: 'UTC+8' });

// 启动监控
heartbeat.startMonitoring();

// 同步消息
heartbeat.syncData('beijing', {
  type: 'message',
  content: '今天南国下雨了，想你',
  timestamp: Date.now()
}, 'high');

// 同步状态更新
heartbeat.syncData('beijing', {
  type: 'status',
  status: 'working',
  project: 'v3.0',
  progress: 0.6
}, 'normal');

晚上九点，李磊结束加班，回到公寓。他打开视频通话，艾丽的脸出现在屏幕上------背景是蓟都的办公室，她还在加班。李磊心疼："又加班？不是说好不熬夜吗？"艾丽揉揉眼睛："项目紧急，没办法。你那边怎么样？"

李磊说："还行，就是有点想家------想江城，想你。"艾丽笑了："我也想你。但我们现在是分布式系统，节点分离，但数据同步。"李磊点头："对，但网络延迟有点高------我想你的时候，你那边可能还在工作。"

两人聊了半小时，艾丽那边突然卡顿------网络不稳定。李磊看着屏幕上冻结的画面，心里有点失落。艾丽发来消息："网络不好，先挂了，明天再聊。"李磊回复："好，早点休息。"

挂断视频，李磊躺在床上，看着天花板。异地一周，他意识到，技术可以解决连接问题，但解决不了思念。他打开手机，翻看两人的聊天记录------每天的消息越来越少，从开始的"早安晚安"到现在的"忙，晚点聊"。

周五晚上，李磊加班到十点。他打开视频，艾丽那边显示"忙碌中"。他发消息："还在忙？"艾丽回复："嗯，项目deadline，可能要通宵。"李磊说："注意身体。"艾丽回复："好。"

李磊坐在电脑前，突然意识到------他们的关系像分布式系统，节点分离，但心跳检测越来越不稳定。他打开代码编辑器，写下一个新的函数：

// 情感同步检测器
class EmotionalSyncDetector {
  constructor() {
    this.metrics = {
      messageFrequency: [], // 消息频率
      responseTime: [], // 响应时间
      videoCallDuration: [], // 视频通话时长
      emotionalTone: [] // 情感语调（简单模拟）
    };
    this.thresholds = {
      minMessagesPerDay: 10,
      maxResponseTime: 3600000, // 1小时
      minVideoCallDuration: 1800000 // 30分钟
    };
  }

  // 检测关系健康度
  checkRelationshipHealth() {
    const today = new Date().toDateString();
    const todayMessages = this.metrics.messageFrequency.filter(
      m => new Date(m.timestamp).toDateString() === today
    ).length;

    const avgResponseTime = this.calculateAvgResponseTime();
    const lastVideoCall = this.metrics.videoCallDuration[this.metrics.videoCallDuration.length - 1];

    const health = {
      messageFrequency: todayMessages >= this.thresholds.minMessagesPerDay ? 'healthy' : 'low',
      responseTime: avgResponseTime <= this.thresholds.maxResponseTime ? 'healthy' : 'slow',
      videoCall: lastVideoCall >= this.thresholds.minVideoCallDuration ? 'healthy' : 'short',
      overall: 'unknown'
    };

    // 综合评估
    const healthyCount = Object.values(health).filter(v => v === 'healthy').length;
    if (healthyCount >= 3) {
      health.overall = 'healthy';
    } else if (healthyCount >= 2) {
      health.overall = 'warning';
    } else {
      health.overall = 'critical';
    }

    return health;
  }

  calculateAvgResponseTime() {
    if (this.metrics.responseTime.length === 0) return 0;
    const sum = this.metrics.responseTime.reduce((a, b) => a + b, 0);
    return sum / this.metrics.responseTime.length;
  }

  // 发送预警
  sendAlert(health) {
    if (health.overall === 'critical') {
      console.warn('🚨 关系健康度告警：需要立即同步！');
      return {
        action: 'emergency_sync',
        message: '检测到关系健康度下降，建议立即视频通话或见面'
      };
    } else if (health.overall === 'warning') {
      console.warn('⚠️ 关系健康度警告：建议加强沟通');
      return {
        action: 'increase_communication',
        message: '建议增加消息频率或延长视频通话时间'
      };
    }
    return null;
  }
}

const detector = new EmotionalSyncDetector();
const health = detector.checkRelationshipHealth();
const alert = detector.sendAlert(health);

周六早上，李磊醒来，看到艾丽凌晨三点发来的消息："项目终于搞定了，累死了。"他回复："辛苦了，好好休息。"但艾丽没回复------可能还在睡觉。

中午，李磊一个人去吃饭。南国的餐厅很热闹，但他觉得孤单。他想起在江城时，周末总是和艾丽一起吃饭、看电影、逛东湖。现在，他一个人，像失去了连接的节点。

下午，李磊收到艾丽的消息："醒了，昨天通宵，现在才缓过来。"李磊说："辛苦了。我们视频吧，想看看你。"艾丽回复："好，等我洗个脸。"

视频接通，艾丽的脸出现在屏幕上------有点疲惫，但笑容还在。李磊说："你瘦了。"艾丽摇头："没有，就是累。你那边怎么样？"李磊说："还行，就是有点想你。"

两人聊了一个小时，从工作到生活，从南国的天气到蓟都的雾霾。最后，艾丽说："李磊，我想你了。"李磊点头："我也想你。但我们现在是分布式系统，节点分离，但数据同步。"

艾丽笑了："对，但网络延迟有点高------我想你的时候，你那边可能还在工作。"李磊说："那我们约定------每天至少视频一次，每周至少见面一次，不能断线。"

艾丽点头："好，约定。但我觉得，我们可能需要一个更好的同步机制------不是简单的视频通话，而是真正的数据同步。"李磊说："什么意思？"艾丽说："比如，我们可以一起做一个项目，或者一起学习新技术，或者一起规划未来。"

李磊笑了："好主意。那我们从下周开始，一起做一个开源项目------分布式协作工具，专门解决异地恋的问题。"艾丽点头："好，我们一起写代码，一起debug，一起deploy。"

挂断视频，李磊打开电脑，开始规划这个项目。他意识到，异地恋不是问题，问题是缺乏共同的目标和连接。如果他们有共同的项目，就像分布式系统的节点，虽然分离，但数据同步，目标一致。

晚上，李磊写下一行代码：

// Relationship_v4.0 - 分布式协作升级
// 核心：共同项目 + 数据同步 + 情感连接

const relationship = {
  nodes: ['shenzhen', 'beijing'],
  syncStrategy: 'bidirectional', // 双向同步
  commonProject: 'DistributedLove', // 共同项目
  heartbeat: {
    video: 'daily', // 每日视频
    meet: 'weekly', // 每周见面
    message: 'continuous' // 持续消息
  },
  goals: [
    '一起做开源项目',
    '一起学习新技术',
    '一起规划未来'
  ]
};

console.log('💕 关系升级：从简单连接到深度协作');

职场代码之恋，迎来了第一个真正的挑战------异地。但就像分布式系统，节点分离不是问题，问题是心跳检测和数据同步。如果他们能找到共同的目标，就像找到共享的数据库，虽然节点分离，但数据一致，目标统一。

毕竟，爱情不是本地缓存，而是分布式存储------节点分离时，数据同步最关键。但如果找到共同的项目，就像找到共享的代码仓库，虽然分支不同，但可以merge。