如果可以估计的话，TList、TObjectList 和普通数组之间的性能差异有多明显？

Question

*总结：

请查看 Delphi 专家的专业评论。特别是对于我来说，我会尝试按照 David 的建议使用旧的 TList/TObjectList，并按照 A.Bouchez 的建议使用硬转换和 TObjectList.List 属性。以后重构的时候我会尝试TDynArray。

=================================================== ===================

假设我有一个 TAtom 类，如以下代码中所定义。运行时大约有数百到数千 TAtom 实例，目前存储在动态数组中。在运行时，我需要对所有现有 TAtom 实例的 TAtom.X/Y/Z 进行简单的浮点数学运算，每秒超过 30 次。

现在，我需要添加在运行时添加、插入、删除 TAtom 实例的功能。看来我的选择是（1）请求一个大数组； (2) 坚持动态数组并手动SetLength； (3)切换到常规TList； (4)切换到常规TObjectList。

除非有必要，否则我想避免 (1)，因为这样我就必须更改很多函数签名。 (2) 看起来也不太好，因为 TList/TObjectList 似乎就是为这个任务而生的。然而，由于使用常规 TList/TObjectList 需要进行类型转换，有人可以评论一下可能的性能影响吗？我的意思是，如果在重写代码之前能够估计性能负担，那就最好了。如果性能明显下降，我可以使用其他技术吗？

此外，我想知道使用 TList 和 TObjectList 是否有性能差异？

  TAtom = class
  public
    ElementZ: Integer;
    X, Y, Z: Extended;  
    other variables: other types;
  end;

  TAAtom = array of TAtom;

Answer 1

我可以在您的清单中添加另一个选择吗？

如果您不对 TAtom 中的数据使用任何继承功能，则可以使用 record 而不是 class。每个类实例都需要在内存中分配，用零填充并单独初始化。 Getmem/Freemem总是有成本的，并且内存碎片会增加。

预先分配的动态记录数组将比添加单个类实例更快。并且数据将更适合CPU L1/L2 缓存。

对于插入和删除，如果您有大量项目，则此类记录的数组将比 TList 慢，因为将有更多数据需要删除/插入 (TList/TObjectList< /code> 都只维护一个指针列表）。为了更快地插入/删除，您最好使用链表。

由于内部通知，TList/TObjectList 机制中存在一些开销。机制 并且 GetItem() 属性可能比直接使用动态数组慢一些（因为范围检查）。

但是使用我们的 TDynArray 包装器，您可以坚持使用动态数组，并且仍然有良好的性能、预分配功能和类似 TList 的方法。甚至还有更多可用方法，例如 SaveToStream、Slice、Reverse、使用外部索引排序等...

type
  TAtom = record // could be 'packed record' to save memory (but loose perf)
    ElementZ: Integer;
    X, Y, Z: Extended;  
    other variables: other types;
    // TDynArray also handle complex (e.g. string) types here
  end;
  TAtoms = array of TAtom;

var Atom: TAtom;
    AtomArray: TAtoms;
    AtomCount: integer;
    Atoms: TDynArray;
begin
  Atoms.Init(TypeInfo(TAtoms),AtomArray,@AtomCount);
  Atoms.Capacity := 10000; // pre-allocate array = same as SetLength(AtomArray,10000)
  for i := 1 to 10000 do begin
    A.ElementZ := Random(1000);
    A.X := Random;
    A.Y := Ramdom;
    A.Z := Random;
    // set other fields
    Atoms.Add(A); // fast adding of A properties
  end;
  // you have TList-like methods for your dynamic array
  Atoms.Delete(500); // delete 500th item
  A.ElementZ := 5000;
  Atoms.Insert(500,A); // insert A values at 500th index
  assert(Atoms.Count=10000);
  assert(AtomCount=10000); // same as Atoms.Count
  Atoms.Compare := SortDynArrayInteger;
  Atoms.Sort; // will sort by 1st Integer value = ElementZ
  for i := 1 to Atoms.Count-1 do // or AtomCount-1
    // you have still direct access to AtomArray[]
    // -> this is even the fastest access to the data
    assert(AtomArray[i].ElementZ >=AtomArray[i-1].ElementZ )
  Atoms.SaveToStream(aStream); // will also save any string content
  Atoms.Reverse; // reverse all items order
  Atoms.Clear;
  // faster adding will be done with direct access to the dynamic array
  Atom.Count := 10000; // allocate memory for 10000 items
  for i := 0 to 10000-1 do
  with AtomArray[i] do
  begin
    ElementZ := Random(2000);
    X := Random;
    Y := Random;
    Z := Random;
  end;
  Atoms.Sort; // TDynArray knows about the data just created
end; // no need to have any try...finally ..Free block

适用于 Delphi 6 到 XE。

随着新版本的 Delphi 支持泛型，您应该更好地朝这个方向发展。

Answer 2

如果您使用 Generics.Collections.TObjectList 并且不需要进行转换。

对于您所描述的用法来说，性能应该很好。插入比添加到末尾要求更高，因为您需要将插入点之后的项目在列表中向上移动。

只要您避免使用 SetLength(A, Length(A)+1) 并选择更合理的分配策略，动态数组就等同于所有 TList 之类的类。

有时，当我尝试将大型列表维护为连续的内存块时，会遇到性能和内存碎片问题。然后我采取了二次分配方案。但是由于您的列表包含本质上是指针的对象引用，因此您已经有了隐式子分配。

这一切都有点推测性，你确实需要测量——否则我们只能猜测。

Answer 3

但是，因为类型转换是
需要使用常规的
TList/TObjectList，有人可以吗
对可能的表现发表评论
命中？

如果您使用表单输入cast，

List[I] as TAtom

则会增加少量开销，这在您的情况下确实会增加。 如果您进行硬类型转换

TAtom(List[I])

但是，据我所知，

，实际上不会发生任何开销，因为类型转换是在没有检查的情况下执行的，而且我也相信它是在编译时完成的。至于你问题的另一方面，我认为它们已经全部得到了适当的涵盖......

Answer 4

制作一个测试项目，测量使用四种方法添加、插入和删除数千个 TAtom 实例的时间。然后决定使用哪一个。

在添加、插入和删除时，TList 和 TObjectList 可能比动态数组更快，因为动态数组需要不断地重新分配。 TList 和 TObjectList 的实现不会这样做。

Answer 5

由于 TObjectList 是 TList 的直接后代，因此性能将非常接近。

Answer 6

第一个问题：我们是在谈论 Classes.TList 和 Contnrs.TObjectList 还是分别在谈论 Generics.Collections.TList Generics .Collections.TObjectList ？

如果我们谈论泛型，TList 和 TObjectList 都是使用动态数组实现的。如果直接使用动态数组或使用通用容器的更好接口之间存在任何性能差异，则可以忽略不计。

---

如果我们谈论“较旧的”TList 和 TObjectList，那么我们只需将 TList 与等效的动态数组进行比较，因为 < code>TObjectList 是 TList 的后代，因此它继承了它的所有性能特征。 TList 使用通过ReallocMem 分配的内存块。动态数组在内部执行相同的操作，因此不应该有显着差异！

结论

如果两者之间存在任何性能差异，则可能是因为动态数组的天真使用使用了可怕的 SetLength(A, Length(A)+1)，而在所有 Delphi 提供的容器中都有更好的实现以更大的块预分配内存。使用正确的代码，这些替代方案之间不应该有任何显着差异！

Answer 7

TList 等完全执行了处理内存块或动态数组的代码必须执行的操作，但它们的实现已经针对常见情况进行了优化，并且包括有关内存管理器行为方式的考虑因素。

一项标准可能是读取/更新与序列的比率。如果序列在创建后很少更新，那么使用动态数组应该可以感觉到更好的速度，因为使用 TList 等访问元素需要一个方法调用加上边界检查，如果使用的话还需要进行类型检查as 运算符。

最后，在 TAtom 上完成的算术成本应该主导运行时间，从而使 dynarray 或 TListXXX 的选择变得无关紧要。

Answer 8

动态记录数组在访问项目时的影响最小，如果你的原子是对象，那么所有列表在访问速度方面都会有些相同。

但是，如果您执行其中许多操作，则关键问题将是插入和删除，所有列表和数组在这方面的性能都会很差，但这正是分析会告诉您的。
如果是这种情况，您可能需要考虑：

• 如果您不需要通过
• 树索引访问原子，那么您可能需要考虑：如果您需要使用原子的空间分区，那么您也可以使用该分区来保存你的原子而不是数组
• 允许数组/列表中的未定义/零元素，并维护一堆未定义/零元素，如果你需要一个排序列表，还需要一个索引（可能是性能最高的解决方案，但也可能是最复杂的）就效率而言是正确的）