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參數設置

通過調用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宕機，Put/Delete的數據將會無法根據WAL日志進行恢復。

2.3 批量寫

通過調用HTable.put(Put)方法可以將一個指定的row key記錄寫入HBase，同樣HBase提供了另一個方法：通過調用HTable.put(List<Put>)方法可以將指定的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); 
    th.start(); 
} 

3. 讀表操作

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

通過調用HTable.setScannerCaching(int scannerCaching)可以設置HBase scanner一次從服務端抓取的數據條數，默認情況下一次一條。通過將此值設置成一個合理的值，可以減少scan過程中next()的時間開銷，代價是scanner需要通過客戶端的內存來維持這些被cache的行記錄。

3.2.2 Scan Attribute Selection

scan時指定需要的Column Family，可以減少網絡傳輸數據量，否則默認scan操作會返回整行所有Column Family的數據。

3.2.3 Close ResultScanner

通過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 getUnitMinutePV(long uid, long startStamp, long endStamp){ 
         long min = startStamp; 
         int count = (int)((endStamp - startStamp) / (60*1000)); 
         List lst = new ArrayList(); 
         for (int i = 0; i <= count; i++) { 
            min = startStamp + i * 60 * 1000; 
            lst.add(uid + "_" + min); 
         } 
         return parallelBatchMinutePV(lst); 
     } 
      //多線程并發查詢，獲取分鐘PV值 
private static ConcurrentHashMap parallelBatchMinutePV(List lstKeys){ 
        ConcurrentHashMap hashRet = new ConcurrentHashMap(); 
        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 lst = new ArrayList(); 
                lstBatchKeys.add(lst); 
            } 
  
            for(int i = 0 ; i < lstKeys.size() ; i ++ ){ 
                lstBatchKeys.get(i%parallel).add(lstKeys.get(i)); 
            } 
        } 
  
        List >> futures = new ArrayList >>(5); 
  
        ThreadFactoryBuilder builder = new ThreadFactoryBuilder(); 
        builder.setNameFormat("ParallelBatchQuery"); 
        ThreadFactory factory = builder.build(); 
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(lstBatchKeys.size(), factory); 
  
        for(List keys : lstBatchKeys){ 
            Callable< ConcurrentHashMap > callable = new BatchMinutePVCallable(keys); 
            FutureTask< ConcurrentHashMap > future = (FutureTask< ConcurrentHashMap >) 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)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 getBatchMinutePV(List lstKeys){ 
        ConcurrentHashMap hashRet = null; 
        List lstGet = new ArrayList(); 
        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(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>{ 
     private List keys; 
  
     public BatchMinutePVCallable(List lstKeys ) { 
         this.keys = lstKeys; 
     } 
  
     public ConcurrentHashMap 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策略，因此BlockCache達到上限(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，以加大緩存的命中率。

有關BlockCache機制，請參考這里：HBase的Block cache，HBase的blockcache機制，hbase中的緩存的計算與使用。

4.數據計算

4.1 服務端計算

Coprocessor運行于HBase RegionServer服務端，各個Regions保持對與其相關的coprocessor實現類的引用，coprocessor類可以通過RegionServer上classpath中的本地jar或HDFS的classloader進行加載。

目前，已提供有幾種coprocessor：

Coprocessor：提供對于region管理的鉤子，例如region的open/close/split/flush/compact等；
RegionObserver：提供用于從客戶端監控表相關操作的鉤子，例如表的get/put/scan/delete等；
Endpoint：提供可以在region上執行任意函數的命令觸發器。一個使用例子是RegionServer端的列聚合，這里有代碼示例。
以上只是有關coprocessor的一些基本介紹，本人沒有對其實際使用的經驗，對它的可用性和性能數據不得而知。感興趣的同學可以嘗試一下，歡迎討論。

4.2 寫端計算

4.2.1 計數

HBase本身可以看作是一個可以水平擴展的Key-Value存儲系統，但是其本身的計算能力有限（Coprocessor可以提供一定的服務端計算），因此，使用HBase時，往往需要從寫端或者讀端進行計算，然后將最終的計算結果返回給調用者。舉兩個簡單的例子：

PV計算：通過在HBase寫端內存中，累加計數，維護PV值的更新，同時為了做到持久化，定期（如1秒）將PV計算結果同步到HBase中，這樣查詢端最多會有1秒鐘的延遲，能看到秒級延遲的PV結果。
分鐘PV計算：與上面提到的PV計算方法相結合，每分鐘將當前的累計PV值，按照rowkey + minute作為新的rowkey寫入HBase中，然后在查詢端通過scan得到當天各個分鐘以前的累計PV值，然后順次將前后兩分鐘的累計PV值相減，就得到了當前一分鐘內的PV值，從而最終也就得到當天各個分鐘內的PV值。

4.2.2 去重

對于UV的計算，就是個去重計算的例子。分兩種情況：

如果內存可以容納，那么可以在Hash表中維護所有已經存在的UV標識，每當新來一個標識時，通過快速查找Hash確定是否是一個新的UV，若是則UV值加1，否則UV值不變。另外，為了做到持久化或提供給查詢接口使用，可以定期（如1秒）將UV計算結果同步到HBase中。
如果內存不能容納，可以考慮采用Bloom Filter來實現，從而盡可能的減少內存的占用情況。除了UV的計算外，判斷URL是否存在也是個典型的應用場景。

4.3 讀端計算

如果對于響應時間要求比較苛刻的情況（如單次http請求要在毫秒級時間內返回），個人覺得讀端不宜做過多復雜的計算邏輯，盡量做到讀端功能單一化：即從HBase RegionServer讀到數據（scan或get方式）后，按照數據格式進行簡單的拼接，直接返回給前端使用。當然，如果對于響應時間要求一般，或者業務特點需要，也可以在讀端進行一些計算邏輯。

5.總結

作為一個Key-Value存儲系統，HBase并不是***的，它有自己獨特的地方。因此，基于它來做應用時，我們往往需要從多方面進行優化改進（表設計、讀表操作、寫表操作、數據計算等），有時甚至還需要從系統級對HBase進行配置調優，更甚至可以對HBase本身進行優化。這屬于不同的層次范疇。

總之，概括來講，對系統進行優化時，首先定位到影響你的程序運行性能的瓶頸之處，然后有的放矢進行針對行的優化。如果優化后滿足你的期望，那么就可以停止優化；否則繼續尋找新的瓶頸之處，開始新的優化，直到滿足性能要求。

以上就是從項目開發中總結的一點經驗，如有不對之處，歡迎大家不吝賜教。

原文鏈接：http://blog.linezing.com/2012/03/hbase-performance-optimization

【編輯推薦】

1. 讓數據庫變快的10個建議
2. 利用Java進行MySql數據庫的導入和導出
3. 20個數據庫設計***實踐
4. 超越MySQL 對流行數據庫進行分支
5. 迎接大數據時代，高手較量數據庫遷移實戰方案