从业务数据到三维实时渲染:Cesium 万级动态目标的工程架构设计

0 阅读23分钟

从业务数据到三维实时渲染:Cesium 万级动态目标的工程架构设计

副标题:从实时数据卡顿、轨迹跳跃到时序缓冲与平滑渲染的完整设计思路

一、业务背景:为什么实时三维地图会出现卡顿?

在低空经济、无人机监管、智慧园区、数字孪生等项目中,经常需要在三维地图中展示大量实时运动目标。

例如,一个无人机监管平台可能需要同时展示 10,000 架以上的无人机,每个目标包含以下数据:

interface TargetData {
  id: string;
  longitude: number;
  latitude: number;
  altitude: number;
  speed: number;
  heading: number;
  timestamp: number;
}

后端通过 WebSocket 持续推送目标的实时位置,前端接收到数据后,将经纬度转换成 Cesium 的三维坐标,并更新地图中的目标位置。

最初的实现方式通常比较直接:

socket.onmessage = (event) => {
  const data = JSON.parse(event.data);

  const position = Cesium.Cartesian3.fromDegrees(
    data.longitude,
    data.latitude,
    data.altitude
  );

  const entity = viewer.entities.getById(data.id);

  if (entity) {
    entity.position = position;
  }
};

这种方式在目标数量较少时没有太大问题,但随着数据规模和推送频率增加,逐渐暴露出一些问题。

1.1 问题一:大量数据更新导致主线程阻塞

假设同时有 10,000 个目标,每个目标每秒推送 5 次位置数据。

那么每秒需要处理:

10,000 × 5 = 50,000 次位置更新。

这还没有计算:

  • WebSocket 消息解析。
  • 经纬度坐标转换。
  • 数据对象创建和销毁。
  • Cesium 对象属性更新。
  • 地图场景更新与绘制。
  • 轨迹线的生成与维护。

JavaScript 主线程除了处理业务代码,还承担浏览器界面交互、事件处理和大量渲染相关工作。

当数据处理任务持续占用主线程时,就可能出现:

  1. 地图拖动、缩放响应变慢。
  2. 鼠标交互延迟。
  3. 页面帧率下降。
  4. 目标位置更新出现明显延迟。
  5. 数据处理速度跟不上数据接收速度。

这里需要注意:问题不一定是 Cesium 本身的渲染能力不足,也可能是数据处理、对象管理和渲染更新共同造成的性能瓶颈。

1.2 问题二:实时位置变化不连续,运动轨迹出现跳跃

这是另一个非常直观的问题。

假设一架无人机每隔 200ms 上报一次位置:

T1:经度 114.3000,纬度 30.5000
T2:经度 114.3010,纬度 30.5010
T3:经度 114.3020,纬度 30.5020
T4:经度 114.3030,纬度 30.5030

前端如果每次收到数据就直接修改目标的位置,实际上显示的是几个离散的位置采样点。

目标的视觉效果就会表现为:

位置 A -------- 位置 B
       突然跳跃

而不是:

位置 A -> 位置 B -> 位置 C -> 位置 D
          连续运动

对于无人机、车辆、船舶等运动目标来说,这种视觉上的跳跃会影响监控体验。

更重要的是,如果数据传输存在网络延迟、抖动或者乱序,前端还可能出现目标向前移动后又突然倒退的现象。

1.3 问题三:异步数据处理导致更新顺序混乱

WebSocket 消息虽然按连接上的发送顺序到达,但后续异步任务并不保证按原始顺序完成。

例如:

socket.onmessage = async (event) => {
  const data = JSON.parse(event.data);

  const result = await processData(data);

  updateTarget(result);
};

假设连续收到三个数据包:

数据 A:timestamp = 1000
数据 B:timestamp = 1200
数据 C:timestamp = 1400

由于异步处理时间不同,实际完成顺序可能变成:

数据 A -> 数据 C -> 数据 B

这样就可能出现旧位置覆盖新位置的问题。

这说明我们需要解决的已经不只是渲染性能问题,还包括数据时序管理问题。


二、第一次思考:能不能把实时数据先排列起来,再逐帧渲染?

面对这些问题,我最初想到的方案是:

既然实时数据存在大量异步更新和位置跳跃,那么能不能先将接收到的数据进行统一整理,按照目标和时间顺序排列起来,再交给 Cesium 进行逐帧显示?

也就是将原来的:

数据到达 -> 立即更新 Cesium

改成:

数据到达
   |
   v
数据收集
   |
   v
数据排序
   |
   v
数据缓存
   |
   v
逐帧输出
   |
   v
Cesium 渲染

这个思路实际上将数据接收和地图渲染拆成了两个独立的过程。

2.1 建立目标数据缓冲区

首先,不再直接把每条 WebSocket 消息交给 Cesium,而是根据目标 ID 建立独立的数据缓存。

interface PositionSample {
  timestamp: number;
  longitude: number;
  latitude: number;
  altitude: number;
}

const targetBuffers = new Map<
  string,
  PositionSample[]
>();

每个目标拥有自己的位置数据序列:

无人机 A:
  T1 -> T2 -> T3 -> T4 -> T5

无人机 B:
  T1 -> T2 -> T3 -> T4 -> T5

无人机 C:
  T1 -> T2 -> T3 -> T4 -> T5

数据进入缓冲区后,根据 timestamp 进行排序。

function insertSample(
  id: string,
  sample: PositionSample
) {
  const buffer = targetBuffers.get(id) ?? [];

  buffer.push(sample);

  buffer.sort(
    (a, b) => a.timestamp - b.timestamp
  );

  targetBuffers.set(id, buffer);
}

这样就可以保证每个目标的位置数据具有时间顺序。

但这里很快会发现一个新问题:

每次插入都进行完整排序,数据量大时会产生额外的计算开销。

例如每个目标已经缓存了 100 条数据,又不断插入新的数据,如果每次都重新排序,显然不是高效方案。

2.2 改进:采用有界时序缓冲区

进一步思考,实时数据不需要无限保存。

我们真正需要的是:

  • 保存最近一段时间的位置采样。
  • 允许少量乱序数据进入缓冲区。
  • 过滤重复和过期数据。
  • 限制缓冲区最大长度。
  • 超出容量时清理已经不需要的数据。

因此,可以设计一个有界时序缓冲区。

class TargetBuffer {
  private samples: PositionSample[] = [];

  private maxSize = 20;

  push(sample: PositionSample) {
    const last = this.samples.at(-1);

    // 正常情况下,按时间顺序直接追加
    if (!last || sample.timestamp > last.timestamp) {
      this.samples.push(sample);
    } else {
      // 处理乱序数据,按时间插入
      const index = this.samples.findIndex(
        item => item.timestamp > sample.timestamp
      );

      if (index === -1) {
        return;
      }

      // 忽略重复时间戳
      if (
        this.samples[index - 1]?.timestamp ===
        sample.timestamp
      ) {
        return;
      }

      this.samples.splice(index, 0, sample);
    }

    // 限制缓存容量
    while (this.samples.length > this.maxSize) {
      this.samples.shift();
    }
  }

  getSamples() {
    return this.samples;
  }
}

这里需要注意,这只是一个便于理解的基础实现。真正的生产版本还需要考虑:

  • 迟到数据的时间窗口。
  • 相同时间戳但不同版本的数据。
  • 二分插入,避免大量线性查找。
  • TypedArray 环形缓冲区。
  • 目标注销后的缓存清理。

对于实时位置数据,还需要区分两种策略:

一种是最新状态优先,过期的位置数据可以直接丢弃。

另一种是轨迹完整性优先,历史采样需要保留,不能简单用最新状态覆盖。

因此,实时显示缓冲区和历史轨迹数据不应该使用完全相同的存储策略。


三、第二次思考:数据排序解决了乱序,为什么目标还是不够平滑?

完成数据排序后,虽然可以避免旧数据覆盖新数据,但目标仍然可能出现跳跃。

原因在于:

排序只是保证数据顺序,并没有增加数据采样点。

例如:

T1:位置 A
T2:位置 B

即使数据已经完全有序,直接显示仍然只有两个离散位置。

因此需要进一步引入时间插值。

3.1 引入统一渲染时间轴

这里可以借鉴视频播放的思路。

视频播放并不是每次接收到一个数据包就立即显示,而是根据播放时钟,持续输出当前时间对应的画面。

三维目标也可以采用类似设计:

  • 数据接收端负责持续采集位置样本。
  • 渲染端拥有独立的播放时钟。
  • 每一帧根据当前渲染时间计算目标位置。
  • Cesium 只负责展示计算后的目标状态。

但是这里有一个关键点:

渲染时间不能简单等于当前系统时间。

因为最新数据可能还没有到达,或者网络传输存在抖动。

因此可以引入一个固定的缓冲延迟。

const BUFFER_DELAY = 150;

function getRenderTime() {
  return Date.now() - BUFFER_DELAY;
}

例如当前时间为 10,000ms,缓冲延迟为 150ms,那么本帧渲染时间为:

渲染时间 = 10,000 - 150
         = 9,850ms

这样就有一定机会拿到渲染时间前后的两个采样点,从而进行插值。

150ms 只是示例值,实际需要根据网络延迟、数据频率和允许的显示延迟进行测试。

3.2 根据时间计算目标当前位置

假设某架无人机有两个采样点:

A:
timestamp = 1000
longitude = 114.3000
latitude  = 30.5000

B:
timestamp = 1200
longitude = 114.3020
latitude  = 30.5020

当前渲染时间为 1100ms。

那么插值比例为:

[
t = \frac{1100-1000}{1200-1000}=0.5
]

此时目标应该位于 A 和 B 的中间位置。

对于简单示例,可以使用线性插值:

function lerp(
  start: number,
  end: number,
  t: number
) {
  return start + (end - start) * t;
}

计算位置:

function interpolatePosition(
  a: PositionSample,
  b: PositionSample,
  renderTime: number
) {
  const duration = b.timestamp - a.timestamp;

  if (duration <= 0) {
    return a;
  }

  const t = Math.max(
    0,
    Math.min(
      1,
      (renderTime - a.timestamp) / duration
    )
  );

  return {
    longitude: lerp(
      a.longitude,
      b.longitude,
      t
    ),
    latitude: lerp(
      a.latitude,
      b.latitude,
      t
    ),
    altitude: lerp(
      a.altitude,
      b.altitude,
      t
    )
  };
}

这样就不再是收到一次数据就移动一次,而是每一帧根据时间计算一个连续的位置。

需要注意,以上经纬度线性插值只适合小范围、短距离的基础示例。跨越较长距离、接近极区或跨越经度 ±180° 时,应考虑转换到 ECEF 三维坐标后插值,或者采用符合运动模型的地理路径计算。

3.3 为什么不能直接使用最新数据?

假设当前时间为 2000ms,但后端最新数据只到 1800ms。

如果直接使用最新位置,那么目标会停留在 1800ms 的位置,等待下一条数据。

如果根据已知速度预测目标位置,则可以在短时间内进行外推。

但是外推并不等于真实位置。

例如:

当前位置 + 速度 × 时间差

只能作为短时间的运动预测。

当目标转弯、减速或者改变高度时,预测误差可能迅速增加。

因此建议:

  • 优先使用前后两个采样点进行插值。
  • 缺少未来采样时,只允许有限时间外推。
  • 超过外推时间阈值后,冻结位置或标记数据过期。
  • 不要无限期预测目标运动。

四、第三次思考:万级目标下,数据处理不能全部依赖主线程

到这里,我们已经解决了数据排序和运动平滑问题。

但又出现了新的瓶颈:

即使不再每次收到数据就立即更新 Cesium,前端仍然需要处理大量数据。

例如:

  • JSON 解析。
  • 数据格式转换。
  • 时间排序。
  • 异常值过滤。
  • 目标状态聚合。
  • 坐标转换。
  • 插值计算。

如果这些任务全部放在主线程,仍然可能影响地图交互。

因此,需要进一步拆分数据处理和渲染职责。

4.1 使用 Web Worker 处理数据

Web Worker 是浏览器原生提供的多线程能力,可以让部分 JavaScript 计算在独立线程中执行。

设计上可以分为:

                WebSocket
                    |
                    v
               主线程接收
                    |
                    v
                数据传输
                    |
                    v
              Web Worker Pool
                    |
         +----------+----------+
         |          |          |
       Worker 1   Worker 2   Worker 3
         |          |          |
         +----------+----------+
                    |
                    v
             数据处理与排序
                    |
                    v
              时序缓冲区
                    |
                    v
               主线程消费
                    |
                    v
               Cesium 渲染

Worker 可以负责:

  1. 数据校验。
  2. 时间戳排序。
  3. 重复数据过滤。
  4. 异常数据检测。
  5. 位置采样缓冲。
  6. 插值所需的数据准备。

主线程主要负责:

  1. Cesium Viewer 管理。
  2. 目标对象生命周期。
  3. 每帧渲染状态读取。
  4. 场景交互。
  5. 目标选中和业务联动。

这里有一个重要边界:

Worker 不是把 Cesium Viewer 整体搬到另一个线程。

普通 Web Worker 无法直接操作主线程中的 DOM 和 Viewer 实例。Cesium 的场景对象、交互以及常规 Viewer 渲染仍然由主线程管理。

Worker 主要负责把计算任务从主线程移出去。

4.2 Transferable:减少数据传输复制开销

使用 Worker 后,又会遇到一个问题:

主线程和 Worker 之间如何高效传递大量数据?

普通 postMessage 会通过结构化克隆算法复制支持的数据对象。

如果每次传递大量复杂对象,依然可能产生开销。

这时可以使用 Transferable Objects。

例如:

const positions = new Float64Array([
  114.3000,
  30.5000,
  100,
  114.3010,
  30.5010,
  120
]);

worker.postMessage(
  {
    positions: positions.buffer
  },
  [positions.buffer]
);

这里传递的是 ArrayBuffer 的所有权。

传递完成后,原线程中的 ArrayBuffer 会被分离,不能继续正常使用。

Worker 接收:

self.onmessage = (event) => {
  const buffer = event.data.positions;

  const positions = new Float64Array(buffer);

  // 在 Worker 中处理数据
};

这种方式适合传递大量连续数值数据。

对于目标数量较大的场景,可以设计紧凑的数据结构:

interface TargetBatch {
  ids: string[];
  positions: Float64Array;
  timestamps: Float64Array;
  speeds: Float32Array;
  headings: Float32Array;
}

每个目标对应固定索引:

index 0:
  longitude
  latitude
  altitude
  timestamp
  speed
  heading

index 1:
  longitude
  latitude
  altitude
  timestamp
  speed
  heading

这样可以减少大量小对象的创建。

但要注意,Transferable 解决的是线程之间的数据传输复制问题,不会自动解决数据处理、排序和 Cesium 渲染本身的性能问题。

另外,如果采用多个 Worker,需要考虑目标分片策略。例如根据 targetId 哈希,将同一个目标始终分配给同一个 Worker,避免同一目标的时序数据在不同 Worker 中发生竞争。


五、第四次思考:数据处理完成了,Cesium 应该如何渲染?

到目前为止,已经完成:

  • 数据接收。
  • 数据排序。
  • 缓冲区管理。
  • 时间插值。
  • Worker 计算分离。
  • 数据批量传输。

接下来就是渲染层的设计。

对于 10,000 个以上的动态目标,不能简单地认为将所有 Entity 换成 Primitive 就一定能解决问题。

因为 Entity 和 Primitive 的设计目标并不完全相同。

5.1 Entity:适合业务交互型对象

Entity 提供较高层次的对象抽象。

优点:

  • 属性管理方便。
  • 支持位置、方向和材质等动态属性。
  • 便于业务事件绑定。
  • 方便目标选中和详情联动。
  • 可以结合 SampledPositionProperty 实现时间采样和插值。

但大量动态 Entity 也会产生对象管理和属性更新成本。

因此适合:

  • 重点监控目标。
  • 当前选中的目标。
  • 需要显示复杂模型和业务属性的对象。
  • 需要进行详细交互的对象。

5.2 Primitive:适合批量几何渲染

Primitive 更接近 Cesium 的底层场景渲染抽象。

通过 GeometryInstance 和 Appearance 可以组织几何数据,并进行批处理。

但需要注意:

Primitive 的批处理优势在静态几何数据中尤其明显。

如果每一帧都重新创建大量 GeometryInstance 和 Primitive,反而可能引入新的性能问题。

对于大量动态点状目标,可以进一步研究:

  • PointPrimitiveCollection。
  • BillboardCollection。
  • 自定义 Primitive。
  • GPU Instancing。
  • TypedArray 批量更新。

因此,我更倾向于将目标分成两类:

目标类型渲染方式业务定位
普通动态目标批量点或自定义实例化渲染高密度展示
重点监控目标Entity交互与业务管理
历史轨迹Polyline / Primitive轨迹展示
告警目标Entity 或独立高亮图层状态强调

5.3 为什么要做渲染分层?

假设当前地图有 10,000 个目标。

其中:

  • 9,700 个是普通目标。
  • 250 个是重点关注目标。
  • 50 个是当前告警目标。

如果所有目标都使用相同的渲染方式,就会造成大量资源浪费。

更合理的方式是:

              10,000 个目标
                    |
          +---------+---------+
          |         |         |
       普通目标   重点目标   告警目标
          |         |         |
       批量渲染    Entity    高亮渲染
          |         |         |
          +---------+---------+
                    |
                 Cesium

这种方式的核心不是单纯追求某一种 API 的性能,而是根据业务对象的重要程度分配不同的渲染资源。


六、第五次思考:每一帧都更新 10,000 个目标,会不会还是太重?

即使已经把数据处理放到了 Worker,如果主线程每一帧仍然需要更新所有目标,依然可能成为性能瓶颈。

例如 60 FPS 的情况下:

10,000 × 60 = 600,000 次目标状态更新/秒。

这里的数字代表每秒需要处理的目标更新次数,并不等于 600,000 次 GPU Draw Call。

因此,还需要引入渲染调度策略。

6.1 目标分级更新

不同目标不一定需要相同的更新频率。

可以根据业务需求分级:

目标类型示例更新频率更新策略
告警目标30 FPS高优先级
重点目标20 FPS正常优先级
普通目标10 FPS批量更新
远距离目标5 FPS降低更新频率

以上频率仅为架构设计示例,需要根据目标速度、屏幕占比和监控精度验证。

6.2 视野范围过滤

如果一个目标已经远离当前地图视野,那么是否还需要维持和屏幕内目标相同的渲染更新频率?

可以考虑:

  • 当前视野内目标:正常更新。
  • 视野边缘目标:低频更新。
  • 视野外目标:保留数据状态,暂停非必要视觉更新。
  • 被选中目标:提升更新优先级。

这里需要区分数据状态和视觉状态。

不能因为目标离开视野,就直接删除它的实时状态,否则重新进入视野时可能出现数据断层。

6.3 帧预算控制

浏览器每帧可用的时间是有限的。

以 60 FPS 为目标时,每帧总预算约为 16.67ms。

但这并不意味着所有业务更新都可以占用这 16.67ms,因为浏览器还需要处理其他工作。

因此可以设计一个帧预算:

const FRAME_BUDGET = 4;

function updateTargets() {
  const start = performance.now();

  while (
    performance.now() - start < FRAME_BUDGET
  ) {
    const target = getNextTarget();

    if (!target) break;

    updateTarget(target);
  }

  requestAnimationFrame(updateTargets);
}

这个方案的核心是将大量更新拆分到多个帧中,避免单帧任务过重。

不过需要注意:如果目标更新速度持续高于消费速度,单纯分帧只会把积压任务转移到下一帧。

因此必须同时控制任务队列长度,并允许普通实时位置数据进行合并和覆盖。


七、最终架构:从实时数据接入到 Cesium 三维渲染

经过前面的分析,整个系统可以拆分为五个层次。

7.1 总体架构

                 后端数据服务
                      |
                      v
                  WebSocket
                      |
                      v
              第一层:数据接入层
              - 消息接收
              - 数据解包
              - 格式校验
                      |
                      v
              第二层:数据处理层
              - Worker Pool
              - 数据排序
              - 重复过滤
              - 异常过滤
              - 状态聚合
                      |
                      v
              第三层:时序缓冲层
              - 按 ID 分组
              - 时间窗口
              - 环形缓冲区
              - 过期数据清理
              - 版本号管理
                      |
                      v
              第四层:运动计算层
              - 统一渲染时钟
              - 时间插值
              - 短时运动预测
              - 目标状态输出
                      |
                      v
              第五层:Cesium 渲染层
              - 普通目标批量渲染
              - 重点目标 Entity
              - 告警目标高亮
              - 历史轨迹展示

7.2 各层职责划分

层级核心职责是否依赖 Cesium
数据接入层接收与解析消息否
数据处理层排序、过滤、聚合否
时序缓冲层保存时间采样否
运动计算层插值与预测尽量不依赖
渲染层地理坐标转换、场景更新是

这里最重要的架构思想是:

让数据处理与三维渲染解耦。

数据层只负责提供某个时间点的目标状态,渲染层只负责将状态转换为三维视觉对象。

这样以后即使更换 Cesium 的渲染方式,或者将部分渲染能力迁移到其他 WebGL 框架,也不需要重新设计整套数据处理逻辑。


八、核心代码设计:统一时间轴驱动目标位置

下面给出一个简化的 TypeScript 设计示例,用来说明时序缓冲和渲染时钟之间的关系。

interface PositionSample {
  timestamp: number;
  longitude: number;
  latitude: number;
  altitude: number;
}

class MotionBuffer {
  private samples: PositionSample[] = [];

  add(sample: PositionSample) {
    const last = this.samples.at(-1);

    if (last && sample.timestamp <= last.timestamp) {
      return;
    }

    this.samples.push(sample);

    // 限制采样窗口
    if (this.samples.length > 20) {
      this.samples.shift();
    }
  }

  getPosition(time: number) {
    const samples = this.samples;

    if (samples.length < 2) {
      return samples[0];
    }

    for (let i = 0; i < samples.length - 1; i++) {
      const a = samples[i];
      const b = samples[i + 1];

      if (
        time >= a.timestamp &&
        time <= b.timestamp
      ) {
        const t =
          (time - a.timestamp) /
          (b.timestamp - a.timestamp);

        return {
          longitude:
            a.longitude +
            (b.longitude - a.longitude) * t,

          latitude:
            a.latitude +
            (b.latitude - a.latitude) * t,

          altitude:
            a.altitude +
            (b.altitude - a.altitude) * t
        };
      }
    }

    return samples[samples.length - 1];
  }
}

主线程统一维护渲染时钟:

const BUFFER_DELAY = 150;

function renderLoop() {
  const renderTime = Date.now() - BUFFER_DELAY;

  for (const [id, motionBuffer] of targetBuffers) {
    const position = motionBuffer.getPosition(
      renderTime
    );

    if (!position) continue;

    updateCesiumTarget(id, position);
  }

  requestAnimationFrame(renderLoop);
}

requestAnimationFrame(renderLoop);

这个示例主要用于说明架构思路,还不是万级目标的最终实现。

实际项目还需要进一步优化:

  1. 使用二分查找确定插值区间。
  2. 清理已经不再需要的历史采样。
  3. 对迟到数据进行有限窗口重排。
  4. 增加目标版本号,防止旧任务覆盖新状态。
  5. 对不同目标使用分级更新策略。
  6. 将普通目标的更新转换成批量渲染数据。
  7. 对 Cesium 对象使用增量更新,避免重复创建和销毁。

另外,示例中的缓冲区只接受递增时间戳,是为了展示核心机制。生产实现需要支持有限乱序插入,不能直接将其当成完整的数据排序方案。


九、还需要考虑的几个工程问题

一个架构设计不能只考虑正常情况下的数据流,还需要考虑异常情况。

9.1 数据堆积怎么办?

假设后端每秒推送 50,000 条数据,而前端每秒只能处理 30,000 条。

如果始终保留全部数据,队列就会越来越大。

因此需要区分:

  • 实时位置:允许同一目标的新状态覆盖旧状态。
  • 历史轨迹:需要按照业务要求完整保存。
  • 告警事件:不能简单覆盖,必须独立进入事件队列。

也就是说,不能所有数据都采用 FIFO 队列。

对于实时位置,可以采用 Latest Wins(最新状态优先)策略。

9.2 数据丢失怎么办?

实时位置和业务事件具有不同的数据可靠性要求。

例如:

无人机当前位置即使丢失一次,也可以等待下一次上报。

但无人机越界告警、设备异常、紧急事件,不能因为队列拥堵而被覆盖。

因此需要把实时状态流和事件流分离。

9.3 Worker 越多越好吗?

不是。

Worker Pool 的目的不是无限增加线程,而是合理利用 CPU 资源。

Worker 数量过多也可能造成:

  • 线程调度开销。
  • 消息传输开销。
  • 多线程竞争。
  • 内存占用增加。

另外,如果每个 Worker 处理的数据量很小,线程通信成本甚至可能高于计算成本。

因此需要根据任务规模、设备 CPU 核数和实际测试结果确定 Worker 数量。

9.4 目标数量增加后,是否一定要使用 GPU Instancing?

不一定。

如果目标是普通点位,可以先研究 PointPrimitiveCollection 或 BillboardCollection。

如果需要大量相同模型、相同几何结构的目标,并且 CPU 端逐个更新已经成为瓶颈,再进一步考虑自定义 Primitive 和 GPU Instancing。

技术选型应该由性能测试结果驱动,而不是一开始就追求最底层的渲染方式。


十、性能验证:如何判断架构是否真正有效?

架构设计最终需要通过测试验证。

建议建立一套可重复的压力测试环境。

10.1 测试场景

测试项测试档位
目标数量1,000 / 5,000 / 10,000
数据推送频率1Hz / 5Hz / 10Hz
数据乱序比例0% / 1% / 5%
目标渲染方式Entity / 批量点渲染
数据处理方式主线程 / Worker
更新方式实时更新 / 时序缓冲插值

10.2 重点监控指标

主线程性能

  • Long Tasks 数量。
  • 主线程任务耗时。
  • JS Heap。
  • 数据处理耗时。

渲染性能

  • FPS。
  • 单帧更新耗时。
  • Cesium 场景更新耗时。
  • GPU 帧耗时(可用工具支持时)。

数据质量

  • 目标位置延迟。
  • 目标位置跳跃次数。
  • 乱序数据覆盖次数。
  • 缓冲区积压量。
  • 丢弃数据量。

10.3 性能优化的验证顺序

不要一开始就同时引入 Worker、Primitive、GPU Instancing 和各种复杂算法。

建议分阶段测试:

  1. 基础版本:WebSocket + Entity 直接更新。
  2. 数据优化:加入排序、过滤和状态聚合。
  3. 时序优化:加入缓冲区和时间插值。
  4. 线程优化:将数据处理迁移到 Worker。
  5. 渲染优化:普通目标改用批量渲染。
  6. 调度优化:加入分级更新和帧预算。

每一步都记录相同测试条件下的性能变化。

这样才能知道到底是哪项优化产生了实际收益。


十一、总结:实时三维渲染的核心不是把数据画出来,而是管理数据的时间与状态

回顾整个设计过程,最初遇到的问题是大量 WebSocket 数据直接更新 Cesium,导致页面卡顿、目标位置跳跃和异步更新顺序混乱。

最初想到的是将数据先进行排序和缓存,再逐帧输出。

在这个思路上进一步发现:

  1. 排序只能解决数据顺序问题,不能解决位置不连续。
  2. 需要建立统一的渲染时间轴,通过插值计算连续位置。
  3. 数据处理不能全部放在主线程,需要 Worker 分担计算任务。
  4. Worker 与主线程之间可以使用 Transferable 降低大块数据的复制成本。
  5. Cesium 渲染层需要根据目标类型进行分层,而不是所有对象统一使用 Entity 或 Primitive。
  6. 即使完成线程分离,也需要控制每帧的渲染任务量。
  7. 实时位置、历史轨迹和告警事件需要采用不同的数据管理策略。

最终形成的架构,不再是简单的:

WebSocket -> Cesium

而是:

实时数据接入
      |
      v
数据标准化与处理
      |
      v
时序缓冲与状态管理
      |
      v
统一时间轴与运动计算
      |
      v
分层批量渲染
      |
      v
Cesium 三维场景

我认为,这类项目真正值得研究的地方,并不只是 Cesium 的某一个 API,而是如何将实时数据处理、时间序列管理、浏览器多线程和三维渲染结合起来。

当目标数量从几十个增长到几千个、上万个时,系统设计的重点也应该从单个对象的更新,逐渐转向整个数据流的组织和调度。

这才是从 Cesium 三维地图开发,走向实时数字孪生工程架构设计的重要一步。


参考资料

说明:本文为面向工程实践的架构设计方案,代码为核心机制示例,不代表已经在 10,000 个真实目标上完成性能验证。实际效果需要结合数据频率、设备性能、目标模型复杂度和浏览器环境进行压测。