bugfix> java > 投稿

FoundationDBは、同じキーを更新しようとする複数のトランザクションがある状況をどのように処理しますか?

1つのクライアントがこのトランザクションを実行する場合:

db.run((Transaction tr) -> {
  tr.set(Tuple.from("key").pack(), Tuple.from("valueA").pack());
  return null;
});

別のクライアントが競合するトランザクションを実行している間:

db.run((Transaction tr) -> {
  tr.set(Tuple.from("key").pack(), Tuple.from("valueB").pack());
  return null;
});

この競合を解決するためにFoundationDB内で何が起こりますか?

回答 1 件
  • 最近、私はFoundationDBを探索し、テストしています(今はみんながそれで遊んでいると思います)。私の探索の一環として、いくつかの簡単なテストを行いました。それらの1つがあなたの質問に答えるべきです:

    そのため、以下に例を示します(Scalaを気にしないでください)。

    import com.apple.foundationdb._
    import com.apple.foundationdb.tuple._
    import resource.managed
    import scala.collection.mutable
    import scala.util.Random
    object Example {
      val THREAD_COUNT = 1
      @volatile var v0: Long = 0
      @volatile var v1: Long = 0
      @volatile var v2: Long = 0
      @volatile var v3: Long = 0
      @volatile var v4: Long = 0
      def doJob(db: Database, x: Int): Unit = {
        db.run((tr) => {
          val key = Tuple.from("OBJ", Long.box(100)).pack()
          val current = Tuple.fromBytes(tr.get(key).join())
          if (Random.nextInt(100) < 2) {
            out(current)
          }
          val next = mutable.ArrayBuffer(current.getLong(0), current.getLong(1), current.getLong(2), current.getLong(3), current.getLong(4))
          if (x == 1 && v1 == next(1)) { println(s"again: $v1, v0=$v0, 0=${next(0)}")}
          if (x == 0 && v0 > next(0)) { out(current); ??? } else { v0 = next(0)}
          if (x == 1 && v1 > next(1)) { out(current); ??? } else { v1 = next(1)}
          if (x == 2 && v2 > next(2)) { out(current); ??? } else { v2 = next(2)}
          if (x == 3 && v3 > next(3)) { out(current); ??? } else { v3 = next(3)}
          if (x == 4 && v4 > next(4)) { out(current); ??? } else { v4 = next(4)}
          next.update(x, next(x) + 1)
          val nv = Tuple.from(next.map(v => Long.box(v)) :_*)
          tr.set(key, nv.pack())
        })
      }
      def main(args: Array[String]): Unit = {
        if (THREAD_COUNT > 5) {
          throw new IllegalArgumentException("")
        }
        val fdb: FDB = FDB.selectAPIVersion(510)
        for (db <- managed(fdb.open())) {
          // Run an operation on the database
          db.run((tr) => {
            for (x <- 0 to 10000) {
              val k = Tuple.from(s"OBJ", x.toLong.underlying()).pack()
              val v = Tuple.from(Long.box(0), Long.box(0), Long.box(0), Long.box(0), Long.box(0)).pack()
              tr.set(k, v)
              null
            }
          })
    
          val threads = (0 to THREAD_COUNT).map { x =>
            new Thread(new Runnable {
              override def run(): Unit = {
                while (true) {
                  try {
                    doJob(db, x)
                  } catch {
                    case t: Throwable =>
                      t.printStackTrace()
                  }
                }
              }
            })
          }
          threads.foreach(_.start())
          threads.foreach(_.join())
    
        }
      }
      private def out(current: Tuple) = {
        println("===")
        println((v0, v1, v2, v3, v4))
        println((Thread.currentThread().getId, current))
      }
    }
    
    

    そのため、このことにより、同じオブジェクトに書き込む複数のスレッドを開始できます。 他の実験から不要なコードが残っていますが、無視してください(または、独自の実験に使用してください)。

    このコードはスレッドを生成し、各スレッドは (0,1,0,0,0) のような5つの長さのタプルを読み取ります  キー ("OBJ", 100) から 、その後増分 スレッド番号に対応する値は、それを書き戻し、揮発性カウンターの1つをインクリメントします。

    そして、これらは私の観察です:

    1つのスレッドで構成されたこの例を実行すると、非常に高速に書き込みが行われることがわかります。

    並行性を高めると、書き込みが遅くなることに気づくでしょう(予想)...

    ...そして、このコードが時々実行されていることがわかります: println(s"again: $v1, v0=$v0, 0=${next(0)}")

    そのため、基本的に、競合が発生すると、FoundationDBクライアントは成功するまでトランザクションをコミットしようとします。詳細については、ドキュメントのこの章を参照してください。次に、アーキテクチャの概要図を見てください。

    また、トランザクションが単なる機能であるというわけでもありません。うまくいけば-べき等関数。

    また、多くの場合、値に対してアトミック操作を使用することで競合を回避できることを知っておく必要があります。

    これがあなたの質問に答えることを願っています。

    多くの公式ドキュメントを読むことをお勧めします。 データベース開発者がCAP定理をどのように考えるか、クールな分散データ構造の良い例、その他多くの技術的詳細や興味深いことなど、そこに興味深いものがあります。

あなたの答え