Question

我正在寻找针对读写器并发问题的数据库解决方案。我需要一个嵌入式数据库，该数据库将由单个编写器进程编写。单个读取器进程将读取同一数据库，并且这些进程将同时运行。

我已经研究过像 RocksDB 这样的解决方案，但是在这里我们可以有多个读取器和一个写入器，但是读取器一次打开后，就没有最新的数据库视图，因此必须再次打开数据库。

任何帮助都会很棒。

编辑

我为RocksDB编写的代码-

writer.cc

#include <cstdio>
#include <string>
#include <unistd.h>
#include <iostream>

#include "rocksdb/db.h"
#include "rocksdb/slice.h"
#include "rocksdb/options.h"

using namespace rocksdb;

std::string kDBPath = "./db";

int main() {
  DB* db;
  Options options;
  options.IncreaseParallelism();
  options.OptimizeLevelStyleCompaction();
  options.create_if_missing = true;

  Status s = DB::Open(options, kDBPath, &db);
  assert(s.ok());

  for (int i = 0 ; ; i++) {
    int key = i;
    Slice kslice((char*)&key, sizeof(int));
    int value = i*i;
    Slice vslice((char*)&value, sizeof(value));
    s = db->Put(WriteOptions(), kslice, vslice);
    std::cout <<  "writing " << i << " : " << i*i << std::endl;
    assert(s.ok());
    sleep(1);
  }
  delete db;
  return 0;
}

输出符合预期：

writing 0 : 0
writing 1 : 1
writing 2 : 4
writing 3 : 9
writing 4 : 16
writing 5 : 25
writing 6 : 36
writing 7 : 49
writing 8 : 64
writing 9 : 81
...

reader.cc

#include <cstdio>
#include <string>
#include <unistd.h>
#include <iostream>

#include "rocksdb/db.h"
#include "rocksdb/slice.h"
#include "rocksdb/options.h"

using namespace rocksdb;
using namespace std;

std::string kDBPath = "./db";

int main() {
  DB* db;
  Options options;
  options.IncreaseParallelism();
  options.OptimizeLevelStyleCompaction();

  Status s = DB::OpenForReadOnly(options, kDBPath, &db);
  assert(s.ok());
  int i = 0;

  while(true) {
    sleep(1);
    std::string value;
    Slice kslice((char*)&i, sizeof(int));
    Status s = db->Get(ReadOptions(), kslice, &value);
    if (!s.ok()) {
      std::cout << i << " " << s.ToString() << std::endl;
      break;
    }
    int a;
    memcpy(&a, value.c_str(), sizeof(a));
    std::cout << i << ":" << a << std::endl;
    i++;
  }
  delete db;
  return 0;
}

输出为（从添加键3开始而不是从键4开始）

0:0
1:1
2:4
3:9
4 NotFound:

我尝试过的一种可能的解决方案是：

  Iterator* it = db->NewIterator(ReadOptions());
  int start = 0;
  Slice kslice((char*)&start, sizeof(int));
  it->Seek(kslice);
  bool flag = true;

  while (true) {
    int key, value;
    for ( ; it->Valid() ; it->Next()) {
      memcpy(&key, it->key().ToString().c_str(), sizeof(int));
      memcpy(&value,  it->value().ToString().c_str(), sizeof(int));
      cout << key << " - " << value << endl;
      if (!it->status().ok()) {
        cout << s.ToString() << endl;
        flag = false;
      }
    }
    if (!flag)
      break;
    sleep(1);
    Status s = DB::OpenForReadOnly(options, kDBPath, &db);
    assert(s.ok());
    Slice kslice((char*)&key, sizeof(int));
    it = db->NewIterator(ReadOptions());
    it->Seek(kslice);
    it->Next();
  }

并且输出符合预期：

writing 0 : 0
writing 1 : 1
writing 2 : 4
writing 3 : 9
writing 4 : 16
writing 5 : 25
writing 6 : 36
writing 7 : 49
writing 8 : 64
writing 9 : 81
...

但是，我想避免每次更新都一次又一次读取数据库。

Answer 1

我建议使用BerkeleyDB（BDB）。您可以在不同的进程中执行并发的读写操作，而不会出现任何问题。数据库负责一致性，您无需显式使用任何锁。

另一个值得注意的数据库LMDB（Lightning Memory Mapped Database）被开发为BDB的直接替代。

那里几乎没有其他可嵌入式数据库。这两个可以满足您的需求。

披露：过去我确实在应用程序中使用过BDB。

Answer 2

RocksDB已明确记录为仅在单个进程内支持多线程并发。您不能在多个进程中安全地使用它。

LMDB已明确记录为支持多进程并发，并且LMDB读取器和写入器在运行时不会互相阻塞。它会做你想要的。

具有并发读写功能的嵌入式数据库

2 个答案: