【问题标题】:Is it a good practice to store the result of a O(1) hashet lookup when used multiple times?多次使用时存储 O(1) 哈希查找的结果是一种好习惯吗?
【发布时间】:2012-08-23 18:32:24
【问题描述】:

我正在使用哈希集结构进行映射:Dictionary<string, string>。

如果我需要在连续语句中多次读取 myHashset["key1"] 的值,使用局部变量存储第一次查找是否是一种好习惯?

编辑:没有其他线程会修改字典,所以它不是一个重要的标准。

谢谢!

【问题讨论】:

  • @Thilo:这不是真正的可比性。属性 getter 比 OP 要求的要便宜得多且可读性强。
  • @DanielHilgarth 取决于吸气剂。如果 getter 查找具有可比类型和大小的字典,则可能完全相同。
  • @JonHanna:如果您在重复访问 getter 时发现性能下降,请继续将其保存到局部变量中。但是,性能并不是我写答案的唯一原因。在字典的情况下使用局部变量不仅可以稍微提高性能,更重要的是,它可以提高代码的可读性。当您用局部变量替换属性 getter 时,这个优势就不存在了,因为属性 getter 已经是可读的。这就是为什么我认为这两个案例不能比较
  • @DanielHilgarth 好吧,这就是我可能将属性读入本地的一个原因 - 例如一个类的通用Count 在方法中可能具有特定含义,我可以相应地命名。不过,在大多数情况下,我同意。
  • @JonHanna:我想我们都同意可读性是这里更重要的一点。

标签: c# .net performance design-patterns dictionary


【解决方案1】:

是的。

O(1) 简单地指出,无论有多少项目,操作都需要相同的时间。
这并不意味着它所花费的时间与访问局部变量一样快。

此外,请考虑以下事项:

  1. 访问局部变量更具可读性
  2. 通常,您希望在通过键访问字典中的值时进行错误处理甚至使用TryGetValue。使用局部变量时,您可以将此代码保存在一个位置,而不必将其涂抹在整个方法中。

【讨论】:

    【解决方案2】:

    是的:

    • 它避免了耗时的多次 O(1) 查找
    • 比每次都写dictionary["key"]可读性强得多

    【讨论】:

      【解决方案3】:

      这是一个很好的做法,至少有两个原因:

      • 字典并不是真正的 O(1)。数据在内部被划分为小集合,字典通过哈希码知道要在哪个集合中搜索。尽管如此,还是涉及到一个内部集合枚举,因此该操作不是免费的(虽然并不昂贵)

      • 可以从另一个线程修改该值。保留引用有助于使您的代码线程安全并防止意外结果。

      【讨论】:

      • 为什么不是 O(1)?当您增加这些集合的数量时,时间不会增加。
      • 如果有很多哈希冲突,字典只会退化到比 O(1) 更糟糕的程度。否则 Dictionary 类是真正的 O(1)。
      • msdn 文档说“接近 O(1)”和“检索取决于散列算法的质量”
      • @Thilo 它的最佳情况是 O(1),它的平均情况非常接近 O(1),没有区别。更糟糕的情况是 O(n) 并且速度很慢(在这种情况下,通过列表搜索会更快)。 O(n) 情况表示一个非常糟糕的哈希码或一种 DoS 攻击,您故意触发它,因此 99% 的时间您可以认为它几乎是 O(1),尽管您应该了解O(1) 场景出现。
      • @Thilo 尝试使用class BadKey{public int Value; public override bool Equals(object o){return o.Value == Value;} public override int GetHashCode(){return 0;}} 的密钥,这是有效的,但非常糟糕。将其中的很多键放入字典中(Value 的值不同),然后将其修复为 public override int GetHashCode(){return Value;} 并再次看到 O(n) 变为 O(1)。
      【解决方案4】:

      执行 n 次 O(1) 操作是 O(n)!

      这是一个小优化,但并非每个小优化都是过早的。确实会节省时间。

      编辑:没有其他线程会修改字典,所以它不是一个重要的标准。

      也许不是手头的案例,但就什么是好的做法而言,我们必须考虑比手头的案例更广泛的案例 - “好的做法”的部分原因在于它涵盖了广泛的只有当我们知道为什么要这样做时,我们才会离开具有相似代码的案例。

      没有线程,我们的原因是:

      1. 我们重复使用相同的代码,结果相同。
      2. 编译器不太可能意识到这一点并为我们重写一次调用。
      3. 它可以增加可读性。

      最后一点值得考虑。变量的每次命名都是使代码自我记录的机会。哪个更清楚发生了什么:

      CheckUpdated(dict[passedValue.split('\t')[1].Trim().ToUpperInvariant()]);
      MarkLastCheckTime(dict[passedValue.split('\t')[1].Trim().ToUpperInvariant()]);
      return GetStatus(dict[passedValue.split('\t')[1].Trim().ToUpperInvariant()];
      

      或者:

      var purchaseOrderCode = dict[passedValue.split('\t')[1].Trim().ToUpperInvariant()];
      CheckUpdated(purchaseOrderCode);
      MarkLastCheckTime(purchaseOrderCode);
      return GetStatus(purchaseOrderCode);
      

      在第一种情况下我有点刻意隐瞒,即使我一直在使用同一个字典,我也应该只做一次这样的工作,但是在实际代码中的影响较小,因为它是一个源文件充满真实代码而不是四行示例。

      使用线程,它变成了一个问题:

      1. 如果我们需要与可能的更改交错,我们不能这样做。
      2. 否则,它消除了线程化带来的许多风险,因为我们正在处理本地并且知道它将始终是相同的本地。

      因此,虽然一些线程案例减轻了这种方法的影响,而且很多人坚持使用它,它不再是一种优化,而是正确性所必需的。

      知道我们所处的情况并考虑其他线程确实变得更加复杂 - 因为在某些情况下,如果另一个线程更新了字典,我们确实希望允许相关对象发生变化。但大多数情况下,我们确实希望确保在面对来自其他线程的更改时继续处理同一个对象。

      因此,虽然在这里并不重要,但它仍然是普遍良好做法的一个原因。

      【讨论】:

        【解决方案5】:

        是的……

        你自己有答案。它将帮助并节省微秒和 CPU 周期。 :)

        【讨论】:

          猜你喜欢
          • 1970-01-01
          • 1970-01-01
          • 2018-05-05
          • 1970-01-01
          • 1970-01-01
          • 2010-09-28
          • 1970-01-01
          • 1970-01-01
          • 2015-01-08
          相关资源
          最近更新 更多