存储系统实现-跳跃表实现索引检索

这一篇是我所实现的一个通过跳跃表的方式进行索引的检索。跳跃表的基本思路把单步检索扩展到多步检索，这样依赖减少检索的步骤来升性能。

先用一张流程图来阐述我检索的步骤。

读索引整体流程图：



这里举一个具体的例子来说一下检索的步骤。这里说一种检索到的情况，假设整个文件表10万条，id是连续自增，检索id=2312的值

第一步：走缓存（这里是第一次检索肯定不能命中缓存）

第二步：走千步长

1）id=1000，小于2312，继续

2）id=2000，小于2312，继续

3) id=3000，大于2312，回退到id=2000的值

第三步：走百步长

1）id=2100，小于2312，继续

2）id=2200，小于2312，继续

3）id=2300，小于2312，继续

4）id=2400，大于2312，回退到id=2300的值

第四步：走十步长

1）id=2310，小于2312，继续

2）id=2320，大于2312，回退到id=2310的值

第五步：走单步长

1）id=2311，小于2312，继续

2）id=2312，等于2312，定位到该值，返回数据

从这里可以看出检索这样一个值，最多只需要11步，如果缓存命中的话只需要一步就找到值，而如果顺序检索的话则需要2312步才能检索到值，这样检索性能得到极大的提升。

下面把两代码代码给贴出来。

/**
* 先走一级步长，如果id>key,回退，走二级步长，id>key,一步一步走
*
* @param id
* @return
*/
public synchronized DataOffset read(int id) {
DataOffset offset = getPosFromCache(id);
if(offset!=null){
return offset;
}
long len;
try {
len = reader.length();
//如果长度大于两倍一级步长，先走一级步长
int key = goByStepLevel(len, 0, id, 0, stepLevel_1000);
if (key != 0) {
key = goByStepLevel(len, reader.getFilePointer(), id, 0, stepLevel_100);
if (key != 0) {
key = goByStepLevel(len, reader.getFilePointer(), id, 0, stepLevel_10);
if (key != 0) {
//直接走0级步长
System.out.println("[IndexFileReader.read]key="+key);
key = goByStepLevel(len, reader.getFilePointer(), id, 0, skip);
}
}
}
System.out.println("[IndexFileReader.read]key2="+key);
if (key == 0) {
//拿到偏移量
reader.readInt();
offset = new DataOffset();
offset.setStartPos(reader.readLong());
//offset.setEndPos(reader.readLong());
//byte[] bytes = ByteUtil.longToByte(offset.getStartPos(),offset.getEndPos());
lruCache.put(indexPath + id, offset.getStartPos());
return offset;
}
} catch (IOException e) {
e.printStackTrace();
}
return null;
}

这个方法是一个私有方法，是一个递归方法，走步长的时候通过递归走步长。

/**
* @param len
* @param nowStep
* @param id
* @param key
* @param stepLevel
* @return 1:代表值还在后面，0:代表该节点即为值，-1:值在前面
* @throws IOException
*/
private int goByStepLevel(long len, long nowStep, int id, int key, long stepLevel)
throws IOException {
//如果后面的步骤已经小于一级步长
if (len > nowStep + stepLevel) {
//如果值仍然在后面,走一级步长
if (id > key) {
nowStep = nowStep + stepLevel;
reader.seek(nowStep);
//这里已经读出一个值了，需要回退
key = reader.readInt();
return goByStepLevel(len, nowStep, id, key, stepLevel);
} else if (id < key) {
//退出，走二级步长
reader.seek(nowStep - stepLevel);
return 1;
} else {
//相等，找到值直接定位到该值
reader.seek(nowStep);
return 0;
}
} else {
//如果值仍然在后面,走二级步长
if (id > key) {
reader.seek(nowStep);
return -1;
} else if (id < key) {
long preStep = nowStep - stepLevel;
if (preStep > 0) {
reader.seek(preStep);
} else {
//如果小于，则直接归0，走二级步长
reader.seek(0);
}
return 1;
} else {
//相等，如果找到值，直接seek到该偏移
reader.seek(nowStep);
return 0;
}
}
}

总结：这里跳跃表的实现就写完了。欢迎大家拍砖