HBase性能优化

HBase性能优化

一，表的设计

1.1 pre-Createing Regions

关于预分区，点击链接–> https://blog.csdn.net/weixin_43270493/article/details/86532733

1.2 Row Key

HBase中row key 用来检索表中的记录，支持以下三种方式：

---- 通过单个 row key访问：即按照某个row key键值进行 get操作。

---- 通过 row key的 range进行 scan：即通过设置startRowKey和stopRowKey，在这个范围内进行扫描。

---- 全表扫描：即直接扫描整张表中所有行记录。

​ 在HBase中，Row Key可以是任意字符串，最大长度是 64kb，实际应用中一般为10~100bytes,存放byte[]数组，一般是设计成定长的。

​ row key 是按照字典序存储，因此，设计row key时，要充分利用这个排序特点，将经常一起读取的数据存储到一块，将最近可能会被访问的数据放在一块。

​ 举个例子：如果最近写入的HBase表中的数据是最可能被访问的，可以考虑将时间戳作为roow key的一部分，由于是字典序排序，所以可以使用Long.MAX_VALUE - timestamp 作为row key，这样能保证在读取新写入的数据可以被快速查找到。

Row Key 规则：

1.定长，越小越好

2.Row Key的设计要根据实际业务来

3.散列性(防止region的热点问题) --> a, 取反(001 --> 100) b, Hash

1.3 Column Family

不要在一个表中定义太多的列族。目前HBase并不能很好的处理超过2~3个列族的表。因为某个列族在flush的时候，它邻近的列族也会因关联效应被触发flush.最终导致系统产生更多的I/O。

1.4 In Memory

创建表的时候，可以通过**HColumnDescriptor.setInMemory(true)**将表放到RegionServer的缓存中，保证在读取的时候被 cache 命中。

1.5 Max Version

创建表的时候，可以通过HColumnDescriptor.setMaxVersion(int Num) 设置表中数据的最大版本。如果只需要保存最新版本的数据，那么设置值为1，默认起始就是1.

1.6 Time To Live

创建表的时候，可以通过**HColumndescriptor.setTimeToLive(int timeToLive)*设置表中数据的存储生命期，过期数据会自动被删除，例如如果只需要存储最近两天的数据，可以设置 timeToLive=2 24 *60 *60(单位默认是秒)

1.7 Compact 和 Split

​ 在HBase中，数据在更新时首先写入到HLog(日志)和内存(MemStore)中，MemStore中的数据是排序的，当MemStore累积到一定阀值时，就会创建一个新的MemStore，并且将老的MemStore放入到flush队列中，由单独的线程flush到磁盘。成为一个storeFile。与此同时，系统会在zookeeper中记录一个 redo point，记录这个时刻之前的变更已经持久化了。

​ StoreFile是只读的，一旦创建后就不可以再修改。因此HBase的更新其实是不断的追加操作。当一个store中的StoreFile数量达到一定的阀值后，就会进行一次合并(major compact),将对同一个key的修改合并到一起，形成一个大的StoreFile，当StoreFile的大小达到一定阀值后，又会对StoreFile进行分割(Spilt)，等分成两个StoreFile.

​ 由于对表的更新是不断追加的，处理请求时，需要访问Store中全部StoreFile和MemStore，将他们按照 row key 进行合并，由于StoreFile和 MemStore都是经过排序的，并且StoreFile带有内存中索引。通常合并过程还是比较快的。

​ 实际应用中，可以考虑必要时手动进行major compact，将同一个 row key的修改合并形成一个大的StoreFile。同时，可以将StoreFile设置大些，减少spilt的发生。

​ HBase为了防止小文件(被刷到磁盘的memstore)过多,以保证查询效率，hbase需要在必要的时候将这些小的store file合并成相对较大的store file，这个过程就称之为compaction. 存在两种类型的 compaction： minor compaction 和 major compaction。

minor compaction --> 较小，很少的文件合并

major compaction --> 将所有的storefile合并成一个，触发major.

​ compaction的可能条件有: major_compaction命令，majorCompact() Api，regionServer自动运行。(相关参数：hbase.hregion.majoucompaction 默认为24 小时， hbase.hregion.majorcompaction.jetter 默认值为0.2 。防止region server 在同一时间进行major compaction）

​ hbase.hregion.majorcompaction.jetter参数的作用是：对参数hbase.hregion.majoucompaction 规定的值起到浮动的作用，假如两个参数都为默认值24和0.2，那么major compact最终使用的数值为：19.2~28.8 这个范围。

​ 关闭自动 major compaction

​ 手动编程 major compaction

minor compaction的运行机制要复杂一些，它由一下几个参数共同决定：

hbase.hstore.compaction.min :默认值为 3，表示一次minor compaction中最少选取3个store file. minor compaction才会启动

hbase.hstore.compaction.max 默认值为10，表示一次minor compaction中最多选取10个store file

hbase.hstore.compaction.min.size 表示文件大小小于该值的store file 一定会加入到minor compaction的store file中

hbase.hstore.compaction.max.size 表示文件大小大于该值的store file 一定会被minor compaction排除

hbase.hstore.compaction.ratio 将store file 按照文件年龄排序（older to younger），minor compaction总是从older store file开始选择

二，写表操作

2.1 多HTable并发写

创建多个HTable客户端用于写操作，提高写数据的吞吐量，一个例子：

static final Configuration conf = HBaseConfiguration.create();
static final String table_log_name = “user_log”;
wTableLog = new HTable[tableN];
for (int i = 0; i < tableN; i++) {
    wTableLog[i] = new HTable(conf, table_log_name);
    wTableLog[i].setWriteBufferSize(5 * 1024 * 1024); //5MB
    wTableLog[i].setAutoFlush(false);
}

2.2 HTable参数设置

2.2.1 Auto Flush

​ 通过调用HTable.setAutoFlush(false)方法可以将HTable写客户端的自动flush关闭，这样可以批量写入数据到HBase，而不是有一条put就执行一次更新，只有当put填满客户端写缓存时，才实际向HBase服务端发起写请求。默认情况下auto flush是开启的。

2.2.2 Write Buffer

​ 通过调用HTable.setWriteBufferSize(writeBufferSize)方法可以设置HTable客户端的写buffer大小，如果新设置的buffer小于当前写buffer中的数据时，buffer将会被flush到服务端。其中，writeBufferSize的单位是byte字节数，可以根据实际写入数据量的多少来设置该值。

2.2.3 WAL Flag

在HBae中，客户端向集群中的RegionServer提交数据时（Put/Delete操作），首先会先写WAL（Write Ahead Log）日志（即HLog，一个RegionServer上的所有Region共享一个HLog），只有当WAL日志写成功后，再接着写MemStore，然后客户端被通知提交数据成功；如果写WAL日志失败，客户端则被通知提交失败。这样做的好处是可以做到RegionServer宕机后的数据恢复。

因此，对于相对不太重要的数据，可以在Put/Delete操作时，通过调用Put.setWriteToWAL(false)或Delete.setWriteToWAL(false)函数，放弃写WAL日志，从而提高数据写入的性能。

注意：谨慎选择关闭 WAL日志。一旦RegionServer宕机，数据将无法通过根据WAL日志进行恢复。

2.3 批量写

​ 通过调用HTable.put(Put)方法将一个指定的 row key记录写入HBase，同样HBase提供了另一个方法，通过调用HTable.put(List)方法可以将指定的row key列表，批量写入多行记录，这样做的好处是批量执行，只需要一次网络I/O开销，这样对于对数据实时性要求性高，网络传输RTT高的情境下带来明显的性能提升。

2.4 多线程并发写

在客户端开启多个HTable写线程，每个写线程负责一个HTable对象的flush操作，这样结合定时flush和写buffer（writeBufferSize），可以既保证在数据量小的时候，数据可以在较短时间内被flush（如1秒内），同时又保证在数据量大的时候，写buffer一满就及时进行flush。下面给个具体的例子：

for (int i = 0; i < threadN; i++) {
    Thread th = new Thread() {
        public void run() {
            while (true) {
                try {
                    sleep(1000); //1 second
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
synchronized (wTableLog[i]) {
                    try {
                        wTableLog[i].flushCommits();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
}
    };
    th.setDaemon(true);

其实说是多线程，但是对比MapReduce程序，捉襟见肘…

三，读表操作

3.1 多HTable并发读

创建多个HTable客户端用于读操作，提高读数据的吞吐量,一个例子

static final Configuration conf = HBaseConfiguration.create();
static final String table_log_name = “user_log”;
rTableLog = new HTable[tableN];
for (int i = 0; i < tableN; i++) {
    rTableLog[i] = new HTable(conf, table_log_name);
    rTableLog[i].setScannerCaching(50);
}

3.2 HTable参数设置

3.2.1 Scanner Caching

​ hbase.client.scanner.caching配置项可以设置HBase scanner一次从服务端抓取的数据条数，默认情况下一次一条。通过将其设置成一个合理的值，可以减少scan过程中next()的时间开销，代价是scanner需要通过客户端的内存来维持这些被cache的行记录。

有三个地方可以进行配置：

1）在HBase的conf配置文件中进行配置；

2）通过调用HTable.setScannerCaching(int scannerCaching)进行配置；

3）通过调用Scan.setCaching(int caching)进行配置。

三者的优先级越来越高。

3.3.2 Scan Attribute Selection

​ scan时指定需要的Column Family，可以减少网络传输数据量，否则默认scan操作或返回整行所有Column Family的数据。

scan.addColumn("cf1".getBytes(),"name".getBytes());

3.3.3 Close ResultScanaer

通过scan取完数据后，记得要关闭ResultScanner，否则RegionServer可能会出现问题(对应的Server资源无法释放)。

3.3 批量读

​ 通过调用HTable.get(Get)方法可以根据一个指定的row key获取一行记录，同样HBase提供了另一个方法：通过调用HTable.get(List)方法可以根据一个指定的row key列表，批量获取多行记录，这样做的好处是批量执行，只需要一次网络I/O开销，这对于对数据实时性要求高而且网络传输RTT高的情景下可能带来明显的性能提升。

3.4 多线程并发读

在客户端开启多个HTable读线程，每个读线程负责通过HTable对象进行get操作。下面是一个多线程并发读取HBase，获取店铺一天内各分钟PV值的例子：

public class DataReaderServer {
     //获取店铺一天内各分钟PV值的入口函数
     public static ConcurrentHashMap<String, String> getUnitMinutePV(long uid, long startStamp, long endStamp){
         long min = startStamp;
         int count = (int)((endStamp - startStamp) / (60*1000));
         List<String> lst = new ArrayList<String>();
         for (int i = 0; i <= count; i++) {
            min = startStamp + i * 60 * 1000;
            lst.add(uid + "_" + min);
         }
         return parallelBatchMinutePV(lst);
     }
      //多线程并发查询，获取分钟PV值
private static ConcurrentHashMap<String, String> parallelBatchMinutePV(List<String> lstKeys){
        ConcurrentHashMap<String, String> hashRet = new ConcurrentHashMap<String, String>();
        int parallel = 3;
        List<List<String>> lstBatchKeys  = null;
        if (lstKeys.size() < parallel ){
            lstBatchKeys  = new ArrayList<List<String>>(1);
            lstBatchKeys.add(lstKeys);
        }
        else{
            lstBatchKeys  = new ArrayList<List<String>>(parallel);
            for(int i = 0; i < parallel; i++  ){
                List<String> lst = new ArrayList<String>();
                lstBatchKeys.add(lst);
            }

            for(int i = 0 ; i < lstKeys.size() ; i ++ ){
                lstBatchKeys.get(i%parallel).add(lstKeys.get(i));
            }
        }
        
        List<Future< ConcurrentHashMap<String, String> >> futures = new ArrayList<Future< ConcurrentHashMap<String, String> >>(5);
        
        ThreadFactoryBuilder builder = new ThreadFactoryBuilder();
        builder.setNameFormat("ParallelBatchQuery");
        ThreadFactory factory = builder.build();
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(lstBatchKeys.size(), factory);
        
        for(List<String> keys : lstBatchKeys){
            Callable< ConcurrentHashMap<String, String> > callable = new BatchMinutePVCallable(keys);
            FutureTask< ConcurrentHashMap<String, String> > future = (FutureTask< ConcurrentHashMap<String, String> >) executor.submit(callable);
            futures.add(future);
        }
        executor.shutdown();
        
        // Wait for all the tasks to finish
        try {
          boolean stillRunning = !executor.awaitTermination(
              5000000, TimeUnit.MILLISECONDS);
          if (stillRunning) {
            try {
                executor.shutdownNow();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
          }
        } catch (InterruptedException e) {
          try {
              Thread.currentThread().interrupt();
          } catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
          }
        }
        
        // Look for any exception
        for (Future f : futures) {
          try {
              if(f.get() != null)
              {
                  hashRet.putAll((ConcurrentHashMap<String, String>)f.get());
              }
          } catch (InterruptedException e) {
            try {
                 Thread.currentThread().interrupt();
            } catch (Exception e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
          } catch (ExecutionException e) {
            e.printStackTrace();
          }
        }
        
        return hashRet;
    }
     //一个线程批量查询，获取分钟PV值
    protected static ConcurrentHashMap<String, String> getBatchMinutePV(List<String> lstKeys){
        ConcurrentHashMap<String, String> hashRet = null;
        List<Get> lstGet = new ArrayList<Get>();
        String[] splitValue = null;
        for (String s : lstKeys) {
            splitValue = s.split("_");
            long uid = Long.parseLong(splitValue[0]);
            long min = Long.parseLong(splitValue[1]);
            byte[] key = new byte[16];
            Bytes.putLong(key, 0, uid);
            Bytes.putLong(key, 8, min);
            Get g = new Get(key);
            g.addFamily(fp);
            lstGet.add(g);
        }
        Result[] res = null;
        try {
            res = tableMinutePV[rand.nextInt(tableN)].get(lstGet);
        } catch (IOException e1) {
            logger.error("tableMinutePV exception, e=" + e1.getStackTrace());
        }

        if (res != null && res.length > 0) {
            hashRet = new ConcurrentHashMap<String, String>(res.length);
            for (Result re : res) {
                if (re != null && !re.isEmpty()) {
                    try {
                        byte[] key = re.getRow();
                        byte[] value = re.getValue(fp, cp);
                        if (key != null && value != null) {
                            hashRet.put(String.valueOf(Bytes.toLong(key,
                                    Bytes.SIZEOF_LONG)), String.valueOf(Bytes
                                    .toLong(value)));
                        }
                    } catch (Exception e2) {
                        logger.error(e2.getStackTrace());
                    }
                }
            }
        }

        return hashRet;
    }
}
//调用接口类，实现Callable接口
class BatchMinutePVCallable implements Callable<ConcurrentHashMap<String, String>>{
     private List<String> keys;

     public BatchMinutePVCallable(List<String> lstKeys ) {
         this.keys = lstKeys;
     }

     public ConcurrentHashMap<String, String> call() throws Exception {
         return DataReadServer.getBatchMinutePV(keys);
     }
}

3.5 缓存查询结果

​ 对于频繁查询HBase的应用场景，可以考虑在应用程序中做缓存，当有新的查询请求时，首先在缓存中查找，如果存在则直接返回，不再查询HBase；否则对HBase发起读请求查询，然后在应用程序中将查询结果缓存起来。至于缓存的替换策略，可以考虑LRU等常用的策略。

3.6 BlockCache

​ HBase上RegionServer的内存分为两个部分：一部分作为 MemStore，主要用来写，一部分为BlockCache，主要用来读。

​ 写请求会先写入MemStore，RegionServer会给每个region提供一个MemStore,当Memstore满64MB以后，会启动flush刷新到磁盘。当MemStore的总大小超过限制时（heapsize * hbase.regionserver.global.memstore.upperLimit * 0.9），会强行启动flush进程，从最大的Memstore开始flush直到低于限制。

​ 读请求先到MemStore中查数据，查不到就到BlockCache中查，再查不到就到磁盘中读取，并把读到的结果放入到BlockCache中。由于BlockCache采用的是LRU策略，因此BlockCahe达到上限(heapsize * hfile.block.cache.size * 0.85)后，淘汰掉最老的一批数据。

​ 一个RegionServer上有一个BlockCache和N个MemStore，它们的大小之和不能大于等于heapsize * 0.8，否则HBase无法启动。默认BlockCache为0.2，而 MemStore为0.4.对于注重读响应时间的系统，可以将BlockCache设置的大些，比如设置BlockCache=0.4，MemStore=0.39,以加大缓存的命中率。

​