Status DB::Open(const Options& options,DB** dbptr) {
  *dbptr = NULL;
 
  DBImpl* impl = new DBImpl(options,dbname);
  impl->mutex_.Lock();
  VersionEdit edit;
  // 如果存在表数据，则Load表数据，并对日志进行恢复，否则，创建新表
  Status s = impl->Recover(&edit);
  if (s.ok()) {
    // 从VersionEdit获取一个新的文件序号，所以如果是新建数据表，则第一个LOG的序号为2（1已经被MANIFEST占用）
    uint64_t new_log_number = impl->versions_->NewFileNumber();
    // 记录日志文件号，创建新的log文件及Writer对象
    WritableFile* lfile;
    s = options.env->NewWritableFile(LogFileName(dbname,new_log_number),&lfile);
    if (s.ok()) {
      edit.SetLogNumber(new_log_number);
      impl->logfile_ = lfile;
      impl->logfile_number_ = new_log_number;
      impl->log_ = new log::Writer(lfile);
      // 如果存在原来的log，则回放log
      s = impl->versions_->LogAndApply(&edit,&impl->mutex_);
    }
    if (s.ok()) {
      // 删除废弃的文件（如果存在）
      impl->DeleteObsoleteFiles();
      // 检查是否需要Compaction，如果需要，则让后台启动Compaction线程
      impl->MaybeScheduleCompaction();
    }
  }
  impl->mutex_.Unlock();
  if (s.ok()) {
    *dbptr = impl;
  } else {
    delete impl;
  }
  return s;
}

Status DBImpl::Recover(VersionEdit* edit) {
  mutex_.AssertHeld();
 
  // 创建DB目录，不关注错误
  env_->CreateDir(dbname_);
  // 在DB目录下打开或创建（如果不存在）LOCK文件并锁定它，防止其他进程打开此表
  Status s = env_->LockFile(LockFileName(dbname_),&db_lock_);
  if (!s.ok()) {
    return s;
  }
  
  if (!env_->FileExists(CurrentFileName(dbname_))) {
    // 如果DB目录下不存在CURRENT文件且允许在表不存在时创建表，则新建一个表返回
    if (options_.create_if_missing) {
      s = NewDB();
      if (!s.ok()) {
        return s;
      }
    } else {
      return Status::InvalidArgument(
          dbname_,"does not exist (create_if_missing is false)");
    }
  } else {
    if (options_.error_if_exists) {
      return Status::InvalidArgument(
          dbname_,"exists (error_if_exists is true)");
    }
  }
  // 如果运行到此，表明表已经存在，需要load，第一步是从MANIFEST文件中恢复VersionSet
  s = versions_->Recover();
  if (s.ok()) {
    SequenceNumber max_sequence(0);
    // 获取MANIFEST中获取最后一次持久化清单时在使用LOG文件序号，注意：这个LOG当时正在使用，
    // 表明数据还在memtable中，没有形成sst文件，所以数据恢复需要从这个LOG文件开始(包含这个LOG)。
    // 另外，prev_log是早前版本level_db使用的机制，现在以及不再使用，这里只是为了兼容
    const uint64_t min_log = versions_->LogNumber();
    const uint64_t prev_log = versions_->PrevLogNumber();
    // 扫描DB目录，记录下所有比MANIFEST中记录的LOG更加新的LOG文件
    std::vector<std::string> filenames;
    s = env_->GetChildren(dbname_,&filenames);
    if (!s.ok()) {
      return s;
    }
    uint64_t number;
    FileType type;
    std::vector<uint64_t> logs;
    for (size_t i = 0; i < filenames.size(); i++) {
      if (ParseFileName(filenames[i],&number,&type)
          && type == kLogFile
          && ((number >= min_log) || (number == prev_log))) {
        logs.push_back(number);
      }
    }
    // 将LOG文件安装从小到大排序
    std::sort(logs.begin(),logs.end());
    // 逐个LOG文件回放    for (size_t i = 0; i < logs.size(); i++) {
      // 回放LOG时，记录被插入到memtable，如果超过write buffer，则还会dump出level 0的sst文件，
      // 此方法会将日志种每条记录的sequence num与max_sequence进行比较，以记录下最大的sequence num。
      s = RecoverLogFile(logs[i],edit,&max_sequence);
      // 更新最大的文件序号，因为MANIFEST文件中没有记录这些LOG文件占用的序号；
      // 当然，也可能LOG的序号小于MANIFEST中记录的最大文件序号，这时不需要更新。
      versions_->MarkFileNumberUsed(logs[i]);
    }
    if (s.ok()) {
      // 比较日志回放前后的最大sequence num，如果回放记录中有超过LastSequence()的记录，则替换
      if (versions_->LastSequence() < max_sequence) {
        versions_->SetLastSequence(max_sequence);
      }
    }
  }
  return s;
}	

4.3 关闭一个已打开的表

DBImpl::~DBImpl() {
  // 通知后台线程，DB即将关闭
  mutex_.Lock();
  // 后台线程会间歇性地检查shutting_down_对象的指针，一旦不为NULL就会退出
  shutting_down_.Release_Store(this);
  // 注意:这里必须循环通知，直至compaction线程获得信号并设置了bg_compaction_scheduled_为false  
  while (bg_compaction_scheduled_) {
    bg_cv_.Wait();
  }
  mutex_.Unlock();
 
  // 如果锁定了文件锁，则释放文件锁
  if (db_lock_ != NULL) {
    env_->UnlockFile(db_lock_);
  }
 
  delete versions_;
  // 减去memtable的引用计数
  if (mem_ != NULL) mem_->Unref();
  if (imm_ != NULL) imm_->Unref();
  // 销毁db log相关对象以及表缓冲对象
  delete log_;
  delete logfile_;
  delete table_cache_;
 
  // 如果info log与cache是引擎自己构建，则需要销毁它们
  if (owns_info_log_) {
    delete options_.info_log;
  }
  if (owns_cache_) {
    delete options_.block_cache;
  }
}