HBase Compaction

当 client 向 hregion 端 put() 数据时， HRegion 会判断当前的 memstore 的大小是否大于参数hbase.hregion.memstore.flush.size 值，如果大于，则执行 flushcache() 操作，将 hregion 上的 memstore 刷新到 store
files 文件里。

而在 flushcache 时，会先判断当前的 region 是否满足以下条件

Store files number > 参数hbase.hstore.blockingStoreFiles 值

如果满足，则会将该 region 放入 CompactSplitThread 线程的队列中，等待被compactsplit 。

接着继续执行flushcache() 操作，将建立快照，然后将快照刷新到hdfs 的store files 上。

Flushcache 完成后，还会再判断store file 数是否大于

参数 hbase.hstore.compaction.min ，如果是，还会将其加入到 CompactSplitThread 队列中。

而在线程中 CompactSplitThread 会对region 进行compact 和split 。

Compact 就是将之前多次刷新到hdfs 上的store files 合并成一个文件，同时将这之前的日志清理干净。

Split 就是将一个大的region 拆分成二个region 。

下面讲一个compact 的合并过程。

之前的 store file 是从 memstore 内存中刷新到 hdfs 上，每个文件是有顺序的，现在就要将这多个有顺序的 store files 组装成一个有顺序的 file 。 Hbase 中是如何进行的呢？

首先对每个store file 包装成StoreFileScanner 类。该类有以下方法。

public KeyValue peek();// 取得当前的kv 。

public KeyValue next()// 取下一个kv 。就是从hdfs 读取下一个kv 。

public boolean seek(KeyValue key)// 对当前的KV 赋值。

然后再对要合并的store files 新建StoreFileScanner 对象。如下代码：

filesToCompact 队列为最原始的Store files 。

List<StoreFileScanner> scanners =

new ArrayList< StoreFileScanner >(filesToCompact.size());

for (StoreFile file : filesToCompact ) {

StoreFile.Reader r = file.createReader();

scanners.add(r.getStoreFileScanner(cacheBlocks, usePread));

}

然后再用 StoreScanner 对象将前面的 StoreFileScanner 对象队列包装一下。

scanner = new StoreScanner( this , scan, scanners, !majorCompaction);

这样一来，只需要调用 scanner 对象的 next() 方法就可以从这些 store files 依次得到有序的 kv 对。

然后再将这些有序的 KV 对有序地 append 到最终新建的 store file 上。

这样就完成了整个合并过程，代码如下：

ArrayList<KeyValue> kvs = new ArrayList<KeyValue>();

while (scanner.next(kvs)) {

if (writer == null && !kvs.isEmpty()) {

writer = createWriterInTmp(maxKeyCount,

this.compactionCompression);

}

if (writer != null) {

// output to writer:

for (KeyValue kv : kvs) {

writer.append(kv);

}

}

}

接下来需要关注的是 StoreScanner 类中的 next() 方法是如何从它的多个 store files 的 StoreFileScanner 对象中获取有序的 kv 对的呢？

首先看 StoreScanner 类的构造函数，这里定义了 KeyValueHeap 对象，将之前定义的 store files 的StoreFileScanner 包装起来。

StoreScanner (Store store, Scan scan, List<? extends KeyValueScanner>
scanners,

boolean retainDeletesInOutput)

throws IOException {

this.store = store;

this.cacheBlocks = false;

this.isGet = false;

matcher = new ScanQueryMatcher(scan, store.getFamily().getName(),

null, store.ttl, store.comparator.getRawComparator(),

store.versionsToReturn(scan.getMaxVersions()), retainDeletesInOutput);

// Seek all scanners to the initial key

for(KeyValueScanner scanner : scanners) {

scanner.seek( matcher.getStartKey() );

}// 将所有的 store files 中 scanner 对象定位到起始的 key 开始。

// Combine all seeked scanners with a heap

heap = new KeyValueHeap (scanners, store.comparator);

// 定义一个 KV 对的堆。

}

StoreScanner.next() 方法中可以看出来在 StoreScanner 取下一个有序的 KV 时，只需要调用KeyValueHeap 的 next() 方法即可返回当前最小的 kv 对象。

KeyValue peeked = this.heap.peek();

if (peeked == null) {

close();

return false;

}

那么最关键的地方就到 KeyValueHeap 类中。

这个类有三个变量，分别如下：

private PriorityQueue<KeyValueScanner> heap = null;

files 的 scanner 对象的队列

private KeyValueScanner current = null;

当前 kv 所在的 scanner 对象

private KVScannerComparator comparator;

scanner 对象的比较类，默认的类是 KVScannerComparator 。

在这里用到 java 中的 PriorityQueue 优先级队列。此队列按照在构造时所指定的顺序对元素排序，可以根据我们指定的 Comparator 来排序。

而这里的比较为就是对调用之前的 store files 的 scanner 对象获得它们当前的 kv ，然后对其进行比较。

public int compare(KeyValueScanner left, KeyValueScanner right) {

int comparison = compare(left.peek(), right.peek());

if (comparison != 0) {

return comparison;

} else {

long leftSequenceID = left.getSequenceID();

long rightSequenceID = right.getSequenceID();

if (leftSequenceID > rightSequenceID) {

return -1;

} else if (leftSequenceID < rightSequenceID) {

return 1;

} else {

return 0;

}

}

}

在构建队列 heap 时，将 store files 的 scanner 对象加入到队列时，会按照 KVScannerComparator 对所有的 store files 的 scanner 对象进行排序，同时保证队首永远是 kv 最小的，并将 kv 最小的 scanner 对象赋值给current 变量。

public KeyValueHeap(List<? extends KeyValueScanner> scanners,

KVComparator comparator) {

this.comparator = new KVScannerComparator(comparator);

if (!scanners.isEmpty()) {

this.heap = new PriorityQueue<KeyValueScanner>(scanners.size(),

this.comparator);

for (KeyValueScanner scanner : scanners) {

if (scanner.peek() != null) {

this.heap.add(scanner);

} else {

scanner.close();

}

}

this.current = heap.poll();

}

}

而调用 Next() 方法时，从 store files 中的 scanner 对象队列中取得下一个最小的 kv 对象，具体代码如下：

public boolean next(List<KeyValue> result, int limit) throws IOException {

if (this.current == null) {

return false;

}

InternalScanner currentAsInternal = (InternalScanner)this.current;

boolean mayContainsMoreRows = currentAsInternal.next(result, limit);// 返回当前最小的 scanner 对象中当前的 k 的 kv 对象

// 对取完最小元素的 scanner 对象向后移动。

KeyValue pee = this.current.peek();

// 如果下一个 kv 对不为 null ，则可以加入到 heap 中，否则不加入。

if (pee == null || !mayContainsMoreRows) {

this.current.close();

} else {

this.heap.add(this.current);

}

this.current = this.heap.poll();// 再从 heap 中取最小元素的 scanner 对象。

return (this.current != null);

}

总结：

用 StoreFileScanner 将 store file 封装好，提供 next() 和 peek() 方法来获取文件的后面的元素和当前元素。

用 KeyValueHeap 将所有 file 的 StoreFileScanner 对象按照 StoreFileScanner 对象当前的 kv 大小进行排序，如果某个 scanner 对象是最小 KV ，则将其往后移获得下一个元素，依次这样下去，直到全部取完为止，来保证顺序。

同样，在 mapreduce 里，也有合并过程，就是在 reduce 端对 map 传输过来的分片进行合并。和 hbase 中的结果合并方法是一致的。

Mapredue 中用 segment 来包装从 map 过来的 file ，提供了对当前文件的读取下一个 kv 的方法， MergeQueue类继承了 PriorityQueue ，同样提供了 next() 方法有序的从多个文件里读取 KV 对，详细代码在 Merger 类中。