levelDB源码阅读-skiplist跳表下
levelDB中的skiplist跳表 下
前言
在跳表 上 中介绍了跳表的基本结构，接下来将要介绍跳表的迭代器和其内部实现的方法。
Iterator -跳表的迭代器
跳表的迭代器实现非常简单，调用了跳表内部的一些实现方法。
// Iteration over the contents of a skip list
class Iterator {
public:
// Initialize an iterator over the specified list.
// The returned iterator is not valid.
explicit Iterator(const SkipList* list);
// Returns true iff the iterator is positioned at a valid node.
bool Valid() const;
// Returns the key at the current position.
// REQUIRES: Valid()
const Key& key() const;
// Advances to the next position.
// REQUIRES: Valid()
void Next();
// Advances to the previous position.
// REQUIRES: Valid()
void Prev();
// Advance to the first entry with a key >= target
void Seek(const Key& target);
// Position at the first entry in list.
// Final state of iterator is Valid() iff list is not empty.
void SeekToFirst();
// Position at the last entry in list.
// Final state of iterator is Valid() iff list is not empty.
void SeekToLast();
//私有成员
private:
const SkipList* list_;
Node* node_;
// Intentionally copyable
};
//...
//迭代器的构造函数
template<typename Key, class Comparator>
inline SkipList<Key,Comparator>::Iterator::Iterator(const SkipList* list) {
list_ = list;
node_ = nullptr;
}
//判断是否合法
template<typename Key, class Comparator>
inline bool SkipList<Key,Comparator>::Iterator::Valid() const {
return node_ != nullptr;
}
//返回key
template<typename Key, class Comparator>
inline const Key& SkipList<Key,Comparator>::Iterator::key() const {
assert(Valid());
return node_->key;
}
//默认从最底层链路跳到next的位置
//之前说过，第0层包含了所有的key
template<typename Key, class Comparator>
inline void SkipList<Key,Comparator>::Iterator::Next() {
assert(Valid());
node_ = node_->Next(0);
}
//跳到前一个Node的位置
template<typename Key, class Comparator>
inline void SkipList<Key,Comparator>::Iterator::Prev() {
// Instead of using explicit "prev" links, we just search for the
// last node that falls before key.
assert(Valid());
//FindLessThan是skipList的一个方法，后面会详细介绍
node_ = list_->FindLessThan(node_->key);
if (node_ == list_->head_) {
node_ = nullptr;
}
}
//Seek是追踪的意思
template<typename Key, class Comparator>
inline void SkipList<Key,Comparator>::Iterator::Seek(const Key& target) {
//设置当前节点为与target的key相等或比target大的node
//FindGreaterOrEqual也是skiplist的一个函数
node_ = list_->FindGreaterOrEqual(target, nullptr);
}
//追踪到头部
template<typename Key, class Comparator>
inline void SkipList<Key,Comparator>::Iterator::SeekToFirst() {
//在skiplist中有一个head_成员
node_ = list_->head_->Next(0);
}
//追踪到尾部
template<typename Key, class Comparator>
inline void SkipList<Key,Comparator>::Iterator::SeekToLast() {
node_ = list_->FindLast();
if (node_ == list_->head_) {
node_ = nullptr;
}
}
skiplist内部方法
NewNode
template<typename Key, class Comparator>
typename SkipList<Key,Comparator>::Node*
SkipList<Key,Comparator>::NewNode(const Key& key, int height) {
//以对齐的方式申请内存
//arena是leveldb的内存池，之后会讲到
//原子指针的大小是根据高度来定的
char* mem = arena_->AllocateAligned(
sizeof(Node) + sizeof(port::AtomicPointer) * (height - 1));
//新建一个节点并且返回
return new (mem) Node(key);
}
RandomHeight
当要插入一个Node的时候，它应该在插入在哪些高度上呢？
在levelDB的实现中，就是使用了生成随机高度的方式。
template<typename Key, class Comparator>
int SkipList<Key,Comparator>::RandomHeight() {
// Increase height with probability 1 in kBranching
static const unsigned int kBranching = 4;
int height = 1;
//生成随机高度的一个方式
//rnd_是跳表的一个内部成员
while (height < kMaxHeight && ((rnd_.Next() % kBranching) == 0)) {
height++;
}
assert(height > 0);
assert(height <= kMaxHeight);
return height;
}
KeyIsAfterNode
字面意思是判断当前Key值是否在Node之后，但是这样说似乎有些突兀，其本质就是比较Key的值和Node中key值的大小（因为跳表是有序的）。
template<typename Key, class Comparator>
bool SkipList<Key,Comparator>::KeyIsAfterNode(const Key& key, Node* n) const {
// null n is considered infinite
//使用比较器
return (n != nullptr) && (compare_(n->key, key) < 0);
}
一些关于find的方法
如果对跳表的结构不够熟悉，这部分理解起来可能有些困难，建议画一个跳表，然后结合图片来进行分析（这里提供一个图片）。
//找一个key值比传入参数key大或者相等的Node并返回
template<typename Key, class Comparator>
typename SkipList<Key,Comparator>::Node* SkipList<Key,Comparator>::FindGreaterOrEqual(const Key& key, Node** prev)
const {
Node* x = head_;
int level = GetMaxHeight() - 1;
while (true) {
//先找到当前节点的next节点
//比较key值和next节点的key值，如果key值大于next节点的key，就说明我们要找的节点在next之后
//反之，就说明我们找到了该高度中我们要找的节点
Node* next = x->Next(level);
if (KeyIsAfterNode(key, next)) {
// Keep searching in this list
//继续搜索当前高度
x = next;
} else {
//prev用于存放每一层中找到的节点的前一个节点
if (prev != nullptr) prev[level] = x;
//如果是最底层，则直接返回
if (level == 0) {
return next;
} else {
// Switch to next list
level--;
}
}
}
}
//找一个比key值比传入参数更小的节点
//如果没有就返回head
template<typename Key, class Comparator>
typename SkipList<Key,Comparator>::Node*
SkipList<Key,Comparator>::FindLessThan(const Key& key) const {
Node* x = head_;
int level = GetMaxHeight() - 1;
while (true) {
assert(x == head_ || compare_(x->key, key) < 0);
Node* next = x->Next(level);
//如果移动到了当前层次尾部或者next->key比传入key值大
if (next == nullptr || compare_(next->key, key) >= 0) {
//如果到了最底层则直接返回
if (level == 0) {
return x;
} else {
// Switch to next list
//搜索下一个层次
level--;
}
} else {
//继续搜索当前层次
x = next;
}
}
}
//找到跳表的尾部
template<typename Key, class Comparator>
typename SkipList<Key,Comparator>::Node* SkipList<Key,Comparator>::FindLast()
const {
Node* x = head_;
int level = GetMaxHeight() - 1;
while (true) {
Node* next = x->Next(level);
//找到了当前层次的尾部
if (next == nullptr) {
//如果是最底层，则直接返回
if (level == 0) {
return x;
} else {
// Switch to next list
level--;
}
} else {
x = next;
}
}
}
insert
插入操作是实现中一个非常重要的部分。
void SkipList<Key,Comparator>::Insert(const Key& key) {
// TODO(opt): We can use a barrier-free variant of FindGreaterOrEqual()
// here since Insert() is externally synchronized.
//指向前一个节点的数组
Node* prev[kMaxHeight];
//调用该函数，并传入参数pre
//可以找到插入key值的节点在每一个高度中插入点的前一个位置
Node* x = FindGreaterOrEqual(key, prev);
// Our data structure does not allow duplicate insertion
assert(x == nullptr || !Equal(key, x->key));
//生成一个随机高度
int height = RandomHeight();
//如果生成的高度大于当前跳表的高度
if (height > GetMaxHeight()) {
//初始化高出的部分
for (int i = GetMaxHeight(); i < height; i++) {
prev[i] = head_;
}
//fprintf(stderr, "Change height from %d to %d\n", max_height_, height);
// It is ok to mutate max_height_ without any synchronization
// with concurrent readers. A concurrent reader that observes
// the new value of max_height_ will see either the old value of
// new level pointers from head_ (nullptr), or a new value set in
// the loop below. In the former case the reader will
// immediately drop to the next level since nullptr sorts after all
// keys. In the latter case the reader will use the new node.
max_height_.NoBarrier_Store(reinterpret_cast<void*>(height));
}
//新建一个节点
x = NewNode(key, height);
//将该节点插入到之前找到的位置上去
for (int i = 0; i < height; i++) {
// NoBarrier_SetNext() suffices since we will add a barrier when
// we publish a pointer to "x" in prev[i].
x->NoBarrier_SetNext(i, prev[i]->NoBarrier_Next(i));
prev[i]->SetNext(i, x);
}
}
** Contains **
是否包含key值的Node
template<typename Key, class Comparator>
bool SkipList<Key,Comparator>::Contains(const Key& key) const {
//调用函数
Node* x = FindGreaterOrEqual(key, nullptr);
//如果相等则返回true
if (x != nullptr && Equal(key, x->key)) {
return true;
} else {
return false;
}
}
总结
以上，我们分析了在levelDB中跳表的具体实现方法，我们可以注意到里面并没有删除操作。 结合跳表的原理和结构来看，这部分也非常好理解。