HBase表的memstore与集群memstore

一直有一个问题，今天调查了一下源码算是明白了。

===问题===

通过java api（如下代码所示）在创建表的时候，可以通过setMemStoreFlushSize函数来指定memstore的大小，

在集群配置文件中，也可以通过配置hbase.hregion.memstore.flush.size来指定memstore大小。

这两个地方指定的memestore的有什么区别和关联？

★参考代码

package api;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.TableName;
import org.apache.hadoop.hbase.client.Admin;
import org.apache.hadoop.hbase.client.Connection;
import org.apache.hadoop.hbase.client.ConnectionFactory;
import org.apache.hadoop.hbase.io.compress.Compression;
import org.apache.hadoop.hbase.regionserver.BloomType;

public class create_table_sample1 {
    public static void main(String[] args) throws Exception {
        Configuration conf = HBaseConfiguration.create();
        conf.set("hbase.zookeeper.quorum", "192.168.1.80,192.168.1.81,192.168.1.82");
        Connection connection = ConnectionFactory.createConnection(conf);
        Admin admin = connection.getAdmin();

        HTableDescriptor desc = new HTableDescriptor(TableName.valueOf("t1"));
        desc.setMemStoreFlushSize(2097152L);          //2M(默认128M)
        desc.setMaxFileSize(10485760L);               //10M(默认10G)

        HColumnDescriptor family1 = new HColumnDescriptor(constants.COLUMN_FAMILY_DF.getBytes());
        family1.setTimeToLive(2 * 60 * 60 * 24);     //过期时间
        family1.setMaxVersions(2);                   //版本数
        desc.addFamily(family1);
        HColumnDescriptor family2 = new HColumnDescriptor(constants.COLUMN_FAMILY_EX.getBytes());
        family2.setTimeToLive(3 * 60 * 60 * 24);     //过期时间
        family2.setMinVersions(2);                   //最小版本数
        family2.setMaxVersions(3);                   //版本数
        family2.setBloomFilterType(BloomType.ROW);   //布隆过滤方式
        desc.addFamily(family2);

        admin.createTable(desc);
        admin.close();
        connection.close();
    }
}

===解答===

源码位置：hbase-1.3.1\hbase-server\src\main\java\org\apache\hadoop\hbase\regionserver\

文件名：HRegion.java

函数名：setHTableSpecificConf

调用位置：HRegion类的构造函数

函数内容：

  void setHTableSpecificConf() {
    if (this.htableDescriptor == null) return;
    long flushSize = this.htableDescriptor.getMemStoreFlushSize();

    if (flushSize <= 0) {
      flushSize = conf.getLong(HConstants.HREGION_MEMSTORE_FLUSH_SIZE,
        HTableDescriptor.DEFAULT_MEMSTORE_FLUSH_SIZE);
    }
    this.memstoreFlushSize = flushSize;
    this.blockingMemStoreSize = this.memstoreFlushSize *
        conf.getLong(HConstants.HREGION_MEMSTORE_BLOCK_MULTIPLIER,
                HConstants.DEFAULT_HREGION_MEMSTORE_BLOCK_MULTIPLIER);
  }

从上面的源代码中可以得到如下结论：

1、HRegion（每个Table会分为很多个HRegion分布在不同的HRegionServer中）对象在创建时，会初始化memstoreFlushSize。

2、它的计算首先是由Table决定的，即每个表可以设定自己的memstoreFlushSize。

通过关键字MEMSTORE_FLUSHSIZE来设定，或通过HTableDescriptor类中的setMemStoreFlushSize()方法来设定。

3、如果表中未设定，则通过集群参数hbase.hregion.memstore.flush.size来初始化。

4、如果集群参数也未配置的话，则默认为1024*1024*128L，即128M。

所以，可以为不同的表配置不同的MemStore大小。需要在创建表的时候指定。

如果表未单独配置，则采用集群的统一配置。默认128M。

===扩展===

上面setHTableSpecificConf的源代码中，还进行了blockingMemStoreSize的初期化，这个参数是什么呢？

从代码中可以看到，这个参数来源于集群配置项hbase.hregion.memstore.block.multiplier。这个参数与hbase.hregion.memstore.flush.size息息相关。

参数作用：

当一个HRegion中的MemStore的总大小（包含多个Store）超过阈值后，会出发flush请求。

该参数是个倍数，表示一个HRegion的MemStore的总大小最大可以是“hbase.hregion.memstore.flush.size”的几倍。

如果超过这个值，则会阻塞该HRegion的写请求，等待flush。

HRegion.java中的put方法。调用了checkResources()

  @Override
  public void put(Put put) throws IOException {
    checkReadOnly();

    // Do a rough check that we have resources to accept a write.  The check is
    // 'rough' in that between the resource check and the call to obtain a
    // read lock, resources may run out.  For now, the thought is that this
    // will be extremely rare; we'll deal with it when it happens.
    checkResources();
    startRegionOperation(Operation.PUT);
    try {
      // All edits for the given row (across all column families) must happen atomically.
      doBatchMutate(put);
    } finally {
      closeRegionOperation(Operation.PUT);
    }
  }

checkResources()方法内容如下：

  /*
   * Check if resources to support an update.
   *
   * We throw RegionTooBusyException if above memstore limit
   * and expect client to retry using some kind of backoff
  */
  private void checkResources() throws RegionTooBusyException {
    // If catalog region, do not impose resource constraints or block updates.
    if (this.getRegionInfo().isMetaRegion()) return;

    if (this.memstoreSize.get() > this.blockingMemStoreSize) {
      blockedRequestsCount.increment();
      requestFlush();
      throw new RegionTooBusyException("Above memstore limit, " +
          "regionName=" + (this.getRegionInfo() == null ? "unknown" :
          this.getRegionInfo().getRegionNameAsString()) +
          ", server=" + (this.getRegionServerServices() == null ? "unknown" :
          this.getRegionServerServices().getServerName()) +
          ", memstoreSize=" + memstoreSize.get() +
          ", blockingMemStoreSize=" + blockingMemStoreSize);
    }
  }

--END--