【问题标题】:How quickly can you atomically increment a value on the Firebase Realtime Database?您能以多快的速度自动增加 Firebase 实时数据库上的值?
【发布时间】:2020-08-15 13:44:03
【问题描述】:

firebaser 在这里

当我最近tweeted 谈到 Firebase 实时数据库中的新 increment() 运算符时,一位队友问increment() 有多快。

我一直在想同样的问题:使用increment(1) 增加一个值的速度有多快?这与using a transaction to increment a value 相比如何?

【问题讨论】:

  • 同样的规则是否也适用于 Firestore?在写入批处理中进行增量调用确保数据写入没有任何问题? (假设 1write/sec/per doc 限制)

标签: javascript node.js firebase-realtime-database


【解决方案1】:

TL;DR

我测试了这些案例:

  1. 使用transaction 调用增加一个值:

    ref.transaction(function(value) {
      return (value || 0) + 1;
    });
    
  2. 使用新的increment 运算符增加一个值:

    ref.set(admin.database.ServerValue.increment(1));
    

增量更快这一事实并不令人惊讶,但是......多少?

结果:

  • 通过事务,我可以每秒增加大约 60-70 次的值。
  • 使用 increment 运算符,我可以每秒增加大约 200-300 次的值。

我是如何进行测试并获得这些数字的

我已经在我的 2016 型号 macBook pro 上运行了测试,并将上面的内容包装在一个使用 client-side Node SDK 的简单 Node.js 脚本中。操作的包装脚本也非常基础:

timer = setInterval(function() {
    ... the increment or transaction from above ...
}, 100);

setTimeout(function() {
  clearInterval(timer);
  process.exit(1);
}, 60000)

所以:每秒增加值 10 次,并在 1 分钟后停止。然后我用这个脚本生成了这个进程的实例:

for instance in {1..10}
do
  node increment.js &
done

因此,这将使用 increment 运算符运行 10 个并行进程,每个进程每秒将值增加 10 次,总共每秒增加 100 个增量。然后我更改了实例数,直到“每秒增量”达到峰值。

然后我写了一个小的script on jsbin 来监听该值,并通过一个简单的低通移动平均滤波器确定每秒的增量数。我在这里遇到了一些麻烦,所以不确定计算是否完全正确。鉴于我的测试结果,它们非常接近,但如果有人想写一个更好的观察者:请做我的客人。 :)

关于测试的注意事项:

  1. 我不断增加进程数量,直到“每秒增量”似乎达到最大值,但我注意到这与我的笔记本电脑粉丝全速运转不谋而合。所以很可能我没有找到服务器端操作的真正最大吞吐量,而是我的测试环境和服务器的组合。因此,当您尝试重现此测试时,很有可能(实际上很可能)您可能会得到不同的结果,尽管increment 的吞吐量当然应该始终显着高于transaction。无论你得到什么结果:请分享它们。 :)

  2. 我使用了客户端 Node.js SDK,因为它最容易上手。使用不同的 SDK 可能会产生略微不同的结果,尽管我希望主要的 SDK(iOS、Android 和 Web)与我得到的非常接近。

  3. 两个不同的队友立即询问我是在单个节点上运行它,还是并行递增多个值。并行增加多个值可能会显示是否存在系统范围的吞吐量瓶颈,或者它是否是特定于节点的(我期望的)。

  4. 如前所述:我的测试工具没有什么特别之处,但我的 jsbin 观察者代码尤其令人怀疑。如果有人想在相同的数据上编写一个更好的观察者,那就表示感谢。


事务和增量运算符如何在幕后工作

要了解transaction 和increment 之间的性能差异,了解这些操作在后台是如何工作的确实很有帮助。对于 Firebase 实时数据库,“幕后”是指客户端和服务器之间通过 Web Socket 连接发送的命令和响应。

Firebase 中的

事务 使用比较和设置方法。每当我们像上面那样开始事务时,客户端都会猜测节点的当前值。如果在该猜测之前从未见过该节点,则为null。它使用该猜测调用我们的事务处理程序,然后我们的代码返回新值。客户端将猜测和新值发送到服务器,服务器执行比较和设置操作:如果猜测正确,则设置新值。如果猜测错误,则服务器拒绝该操作并将实际当前值返回给客户端。

在一个完美的场景中,最初的猜测是正确的,并且该值会立即写入服务器上的磁盘(然后发送给所有侦听器)。在如下所示的流程图中:

            Client            Server

               +                   +
 transaction() |                   |
               |                   |
        null   |                   |
     +---<-----+                   |
     |         |                   |
     +--->-----+                   |
         1     |     (null, 1)     |
               +--------->---------+
               |                   |
               +---------<---------+
               |     (ack, 3)      |
               |                   |
               v                   v

但是如果节点已经在服务器上有值,它会拒绝写入,发回实际值,客户端再试一次:

            Client            Server

               +                   +
 transaction() |                   |
               |                   |
        null   |                   |
     +---<-----+                   |
     |         |                   |
     +--->-----+                   |
         1     |                   |
               |     (null, 1)     |
               +--------->---------+
               |                   |
               +---------<---------+
               |     (nack, 2)     |
               |                   |
         2     |                   |
     +---<-----+                   |
     |         |                   |
     +--->-----+                   |
         3     |      (2, 3)       |
               +--------->---------+
               |                   |
               +---------<---------+
               |      (ack, 3)     |
               |                   |
               |                   |
               v                   v

这还不算太糟糕,多了一次往返。即使 Firebase 会使用悲观锁定,它也需要往返,所以我们不会丢失任何东西。

如果多个客户端同时修改相同的值,问题就开始了。这会在节点上引入所谓的争用,如下所示:

            Client            Server                Client
               +                   +                   +
 transaction() |                   |                   |
               |                   |                   | transaction()
        null   |                   |                   |
     +---<-----+                   |                   |  null
     |         |                   |                   +--->----+
     +--->-----+                   |                   |        |
         1     |                   |                   +---<----+ 
               |     (null, 1)     |                   |   1
               +--------->---------+    (null, 1)      |
               |                   |---------<---------+
               +---------<---------+                   |
               |     (nack, 2)     |--------->---------+
               |                   |     (nack, 2)     |
         2     |                   |                   |
     +---<-----+                   |                   |   2
     |         |                   |                   |--->----+
     +--->-----+                   |                   |        |
         3     |      (2, 3)       |                   |---<----+ 
               +--------->---------+                   |   3
               |                   |                   |
               +---------<---------+                   |
               |      (ack, 3)     |       (2, 3)      |
               |                   |---------<---------+
               |                   |                   |
               |                   |--------->---------+
               |                   |    (nack, 3)      |
               |                   |                   |   3
               |                   |                   |--->----+
               |                   |                   |        |
               |                   |                   |---<----+ 
               |                   |                   |   4
               |                   |       (3, 4)      |
               |                   |---------<---------+
               |                   |                   |
               |                   |--------->---------+
               |                   |     (ack, 4)      |
               |                   |                   |
               v                   v                   v

TODO:更新上面的图表,使服务器上的操作不会重叠。

第二个客户端必须对其操作进行另一次重试,因为服务器端的值在其第一次和第二次尝试之间已被修改。我们向该位置写入的客户端越多,您看到重试的可能性就越大。 Firebase 客户端会自动执行这些重试,但在多次重试后它将放弃并向应用程序引发 Error: maxretry 异常。

这就是我只能每秒增加一个计数器大约 60-70 次的原因:如果写入次数超过此值,则节点上的争用过多。

增量操作本质上是原子的。您是在告诉数据库:无论当前值是多少,都将其设为x 更高。这意味着客户端永远不必知道节点的当前值,因此它也不会猜错。它只是告诉服务器要做什么。

使用increment时,我们的多客户端流程图如下所示:

            Client            Server                Client

               +                   +                   +
  increment(1) |                   |                   |
               |                   |                   | increment(1)
               |  (increment, 1)   |                   |
               +--------->---------+   (increment, 1)  |
               |                   |---------<---------+
               +---------<---------+                   |
               |      (ack, 2)     |--------->---------+
               |                   |     (ack, 3)      |
               |                   |                   |
               v                   v                   v

仅最后两个流程图的长度就可以很好地解释为什么increment 在这种情况下要快得多:increment 操作就是为此而设计的,所以有线协议更接近地代表了什么我们正在努力完成。这种简单性导致仅在我的简单测试中就产生了 3 到 4 倍的性能差异,在生产场景中可能甚至更多。

当然事务仍然有用,因为除了递增/递减之外还有更多的原子操作。

【讨论】:

  • 你能在增加(1)之前检查值是否为空吗?我知道这就像交易,但我想利用速度。像 increaseIfNotNull(1) 这样的东西会很棒。
  • 不,这确实需要交易。
  • @FrankvanPuffelen 感谢您的详细帖子!真的很感激。如果参考路径不可用会怎样?它会自动创建并增加它吗?顺便说一句,你手动输入了那个大流程图吗?
  • 如果还没有值,则交易和增量的初始值为0。是的,这是手工工作,所以总是赞赏额外的支持。 :)
  • 这非常方便。一个建议:让“增量(增量)”接收一个获取当前值并返回布尔值的函数。这将使这个新功能更加强大。有时您可能只想减少或增加直到某个天花板或地板
猜你喜欢
  • 1970-01-01
  • 2021-08-24
  • 1970-01-01
  • 2023-03-23
  • 1970-01-01
  • 2021-07-22
  • 1970-01-01
  • 2021-12-31
  • 1970-01-01
相关资源
最近更新 更多