Hadoop之Hbase从入门到精通

1、一、 HBase性能调优我们经常看到一些文章吹嘘某产品如何如何快，如何如何强，而自己测试时却不如描述的一些数据。其实原因可能在于你还不是真正理解其内部结构，对于其性能调优方法不够了解。本文转自TaoBao的Ken Wu同学的博客，是目前看到比较完整的HBase调优文章。原文链接：HBase性能调优因官方Book Performance Tuning部分章节没有按配置项进行索引，不能达到快速查阅的效果。所以我以配置项驱动，重新整理了原文，并补充一些自己的理解，如有错误，欢迎指正。配置优化默认值：3分钟（180000ms）说明：RegionServer与Zookeeper间的连接超时时间。当超时时

2、间到后，ReigonServer会被Zookeeper从RS集群清单中移除，HMaster收到移除通知后，会对这台server负责的regions重新balance，让其他存活的RegionServer接管.调优：这个timeout决定了RegionServer是否能够及时的failover。设置成1分钟或更低，可以减少因等待超时而被延长的failover时间。不过需要注意的是，对于一些Online应用，RegionServer从宕机到恢复时间本身就很短的（网络闪断，crash等故障，运维可快速介入），如果调低timeout时间，反而会得不偿失。因为当ReigonServer被正式从RS集群中

3、移除时，HMaster就开始做balance了（让其他RS根据故障机器记录的WAL日志进行恢复）。当故障的RS在人工介入恢复后，这个balance动作是毫无意义的，反而会使负载不均匀，给RS带来更多负担。特别是那些固定分配regions的场景。hbase默认值：10说明：RegionServer的请求处理IO线程数。调优：这个参数的调优与内存息息相关。较少的IO线程，适用于处理单次请求内存消耗较高的Big PUT场景（大容量单次PUT或设置了较大cache的scan，均属于Big PUT）或ReigonServer的内存比较紧张的场景。较多的IO线程，适用于单次请求内存消耗低，TPS要求非常高

4、的场景。设置该值的时候，以监控内存为主要参考。这里需要注意的是如果server的region数量很少，大量的请求都落在一个region上，因快速充满memstore触发flush导致的读写锁会影响全局TPS，不是IO线程数越高越好。压测时，开启Enabling RPC-level logging，可以同时监控每次请求的内存消耗和GC的状况，最后通过多次压测结果来合理调节IO线程数。这里是一个案例 Hadoop and HBase Optimization for Read Intensive Search Applications，作者在SSD的机器上设置IO线程数为100，仅供参考

5、。默认值：256M说明：在当前ReigonServer上单个Reigon的最大存储空间，单个Region超过该值时，这个Region会被自动split成更小的region。调优：小region对split和compaction友好，因为拆分region或compact小region里的storefile速度很快，内存占用低。缺点是split和compaction会很频繁。特别是数量较多的小region不停地split, compaction，会导致集群响应时间波动很大，region数量太多不仅给管理上带来麻烦，甚至会引发一些Hbase的bug。一般512以下的都算小region。大region

6、，则不太适合经常split和compaction，因为做一次compact和split会产生较长时间的停顿，对应用的读写性能冲击非常大。此外，大region意味着较大的storefile，compaction时对内存也是一个挑战。当然，大region也有其用武之地。如果你的应用场景中，某个时间点的访问量较低，那么在此时做compact和split，既能顺利完成split和compaction，又能保证绝大多数时间平稳的读写性能。既然split和compaction如此影响性能，有没有办法去掉？compaction是无法避免的，split倒是可以从自动调整为手动。只要通过将这个参数值调大到某个很

7、难达到的值，比如100G，就可以间接禁用自动split（RegionServer不会对未到达100G的region做split）。再配合RegionSplitter这个工具，在需要split时，手动split。手动split在灵活性和稳定性上比起自动split要高很多，相反，管理成本增加不多，比较推荐online实时系统使用。内存方面，小region在设置memstore的大小值上比较灵活，大region则过大过小都不行，过大会导致flush时app的IO wait增高，过小则因store file过多影响读性能。默认值：0.4/0.35upperlimit说明：hbase.hregion.m

8、emstore.flush.size 这个参数的作用是 当单个memstore达到指定值时，flush该memstore。但是，一台ReigonServer可能有成百上千个memstore，每个memstore也许未达到flush.size，jvm的heap就不够用了。该参数就是为了限制memstores占用的总内存。当ReigonServer内所有的memstore所占用的内存总和达到heap的40%时，HBase会强制block所有的更新并flush这些memstore以释放所有memstore占用的内存。lowerLimit说明： 同upperLimit，只不过当全局memstore的内

9、存达到35%时，它不会flush所有的memstore，它会找一些内存占用较大的memstore，做个别flush，当然更新还是会被block。lowerLimit算是一个在全局flush导致性能暴跌前的补救措施。为什么说是性能暴跌？可以想象一下，如果memstore需要在一段较长的时间内做全量flush，且这段时间内无法接受任何读写请求，对HBase集群的性能影响是很大的。调优：这是一个Heap内存保护参数，默认值已经能适用大多数场景。它的调整一般是为了配合某些专属优化，比如读密集型应用，将读缓存开大，降低该值，腾出更多内存给其他模块使用。这个参数会给使用者带来什么影响？比如，10G内存，1

10、00个region，每个memstore 64M，假设每个region只有一个memstore，那么当100个memstore平均占用到50%左右时，就会达到lowerLimit的限制。假设此时，其他memstore同样有很多的写请求进来。在那些大的region未flush完，就可能又超过了upperlimit，则所有region都会被block，开始触发全局flush。不过，除了你的内存非常小或你的应用场景里大多数都是读，我觉得不需要去调这个参数。默认值：0.2说明：storefile的读缓存占用Heap的大小百分比，0.2表示20%。该值直接影响数据读的性能。调优：当然是越大越好，如果读比

11、写少，开到0.4-0.5也没问题。如果读写较均衡，0.3左右。如果写比读多，果断默认吧。设置这个值的时候，你同时要参考 hbase.regionserver.global.memstore.upperLimit ，该值是memstore占heap的最大百分比，两个参数一个影响读，一个影响写。如果两值加起来超过80-90%，会有OOM的风险，谨慎设置。默认值：7说明：在compaction时，如果一个Store（Coulmn Family）内有超过7个storefile需要合并，则block所有的写请求，进行flush，限制storefile数量增长过快。调优：block写请求会影响当前regi

12、on的性能，将值设为单个region可以支撑的最大store file数量会是个不错的选择，即允许comapction时，memstore继续生成storefile。最大storefile数量可通过region size/memstore size来计算。如果你将region size设为无限大，那么你需要预估一个region可能产生的最大storefile数。默认值：2说明：当一个region里的memstore超过单个memstore.size两倍的大小时，block该region的所有请求，进行flush，释放内存。虽然我们设置了memstore的总大小，比如64M，但想象一下，在最后6

13、3.9M的时候，我Put了一个100M的数据，此时memstore的大小会瞬间暴涨到超过预期的memstore.size。这个参数的作用是当memstore的大小增至超过memstore.size时，block所有请求，遏制风险进一步扩大。调优： 这个参数的默认值还是比较靠谱的。如果你预估你的正常应用场景（不包括异常）不会出现突发写或写的量可控，那么保持默认值即可。如果正常情况下，你的写请求量就会经常暴长到正常的几倍，那么你应该调大这个倍数并调整其他参数值，比如hfile.block.cache.size和hbase.regionserver.global.memstore.upperLimi

14、t/lowerLimit，以预留更多内存，防止HBase server OOM。其他启用LZO压缩LZO对比Hbase默认的GZip，前者性能较高，后者压缩比较高，具体参见 Using LZO Compression。对于想提高HBase读写性能的开发者，采用LZO是比较好的选择。对于非常在乎存储空间的开发者，则建议保持默认。不要在一张表里定义太多的Column FamilyHbase目前不能良好的处理超过包含2-3个CF的表。因为某个CF在flush发生时，它邻近的CF也会因关联效应被触发flush，最终导致系统产生更多IO。批量导入在批量导入数据到Hbase前，你可以通过预先创建

15、regions，来平衡数据的负载。详见 Table Creation: Pre-Creating Regions避免CMS concurrent mode failureHBase使用CMS GC。默认触发GC的时机是当年老代内存达到90%的时候，这个百分比由 -XX:CMSInitiatingOccupancyFraction=N 这个参数来设置。concurrent mode failed发生在这样一个场景：当年老代内存达到90%的时候，CMS开始进行并发垃圾收集，于此同时，新生代还在迅速不断地晋升对象到年老代。当年老代CMS还未完成并发标记时，年老代满了，悲剧就发生了。CMS因

16、为没内存可用不得不暂停mark，并触发一次全jvm的stop the world（挂起所有线程），然后采用单线程拷贝方式清理所有垃圾对象。这个过程会非常漫长。为了避免出现concurrent mode failed，我们应该让GC在未到90%时，就触发。通过设置 -XX:CMSInitiatingOccupancyFraction=N这个百分比， 可以简单的这么计算。如果你的 hfile.block.cache.size 和 hbase.regionserver.global.memstore.upperLimit 加起来有60%（默认），那么你可以设置 70-8

17、0，一般高10%左右差不多。Hbase客户端优化AutoFlush将HTable的setAutoFlush设为false，可以支持客户端批量更新。即当Put填满客户端flush缓存时，才发送到服务端。默认是true。Scan Cachingscanner一次缓存多少数据来scan（从服务端一次抓多少数据回来scan）。默认值是 1，一次只取一条。Scan Attribute Selectionscan时建议指定需要的Column Family，减少通信量，否则scan操作默认会返回整个row的所有数据（所有Coulmn Family）。Close ResultScanners通过scan取完数

18、据后，记得要关闭ResultScanner，否则RegionServer可能会出现问题（对应的Server资源无法释放）。Optimal Loading of Row Keys当你scan一张表的时候，返回结果只需要row key（不需要CF, qualifier,values,timestaps）时，你可以在scan实例中添加一个filterList，并设置 MUST_PASS_ALL操作，filterList中add FirstKeyOnlyFilter或KeyOnlyFilter。这样可以减少网络通信量。Turn off WAL on Puts当Put某些非重要数据时，你可以设

19、置writeToWAL(false)，来进一步提高写性能。writeToWAL(false)会在Put时放弃写WAL log。风险是，当RegionServer宕机时，可能你刚才Put的那些数据会丢失，且无法恢复。启用Bloom FilterBloom Filter通过空间换时间，提高读操作性能二、 关于HFile的思考本文是一篇转载文章，原文作者郭鹏（逖靖寒），国内Cassandra领域的先驱者和实践者。资深软件开发工程师，擅长分布式应用程序的开发和使用，实践经验极其丰富。在本文中，作者推荐了HFile文件格式的经典论文，并对HFile的block size的应用进行了实例探讨。0.90.x

20、版本的HBase中的文件是存储在HFile中的。关于HFile文件的详细介绍，可以查看这篇文章：hfile.pdf这篇文章中介绍了以下五点内容：· HFile的作用。· HFile的格式。· HFile的性能。· HFile的使用注意事项。· HFile的编程接口。HFile中有一个很重要的参数，那就是block size。如果我们写入hfile中的某一个value的值大于block size会怎么样？于是有如下的测试代码：/ create local file systemFileSystem fs = new RawLocalFileSys

21、tem();fs.setConf(new Configuration();/ block size = 1kbHFile.Writer hwriter = new HFile.Writer(fs, new Path("hfile"), 1, (Compression.Algorithm) null, null);/ create key & value, the value is 8kb, larger than 1kbbyte key = "".getBytes();byte value = new byte

22、8 * 1024;for (int i = 0; i < 8 * 1024; i+) valuei = '0'/ add values to hfilefor (int i = 0; i < 10; i+) hwriter.append(key, value);/ close hfilehwriter.close();上面的代码可以看出来，每一个value的值都是8kb，已经超过了hfile预设的1kb的block size。实际的写入情况是如果value大于block size，那么就按照实际的情况来写。上面的测试用例执行完毕以后，整个hile文件只有1个data

23、 block。这个hfile的读取代码如下：/ create local file systemFileSystem fs = new RawLocalFileSystem();fs.initialize(URI.create("file:/"), new Configuration();fs.setConf(new Configuration();HFile.Reader hreader = new HFile.Reader(fs,new Path("hfile"), null, false);/ loadFileInfohreader.loadFil

24、eInfo();HFileScanner hscanner = hreader.getScanner(false, false);/ seek to the start position of the hfile.hscanner.seekTo();/ print index = 1;while (hscanner.next() System.out.println("index: " + index+);System.out.println("key: " + hscanner.getKeyString();System.out.

25、println("value: " + hscanner.getValueString();/ close hfile.hreader.close();上面的代码将读取hfile，并将这个文件中的所有kv打印出来。通过上面的测试可以看出：如果某一个key有非常非常多的value，那么查找这些value就无法通过索引去快速查找，而是需要通过遍历进行。另外，JIRA上面的HBASE-3857也提出了一种新的HFile格式，HFile v2他主要是针对现有HFile的两个主要缺陷提出来的：· 暂用过多内存· 启动加载时间缓慢有兴趣的朋友可以详细了解一下。三、

26、HBase性能优化方法总结1. 表的设计1.1 Pre-Creating Regions默认情况下，在创建HBase表的时候会自动创建一个region分区，当导入数据的时候，所有的HBase客户端都向这一个region写数据，直到这个region足够大了才进行切分。一种可以加快批量写入速度的方法是通过预先创建一些空的regions，这样当数据写入HBase时，会按照region分区情况，在集群内做数据的负载均衡。有关预分区，详情参见：Table Creation: Pre-Creating Regions，下面是一个例子：123456789101112131415161718192021222

27、3242526public static boolean createTable(HBaseAdmin admin, HTableDescriptor table, byte splits) throws IOException   try     admin.createTable(table, splits);     return true;    catch (TableExistsException e)     logger

28、.info("table " + table.getNameAsString() + " already exists");     / the table already exists.     return false;      public static byte getHexSplits(String startKey, String endKey, int numRegions)   byte split

29、s = new bytenumRegions-1;   BigInteger lowestKey = new BigInteger(startKey, 16);   BigInteger highestKey = new BigInteger(endKey, 16);   BigInteger range = highestKey.subtract(lowestKey);   BigInteger regionIncrement = range.divide(BigInteger.valueOf(numRegion

30、s);   lowestKey = lowestKey.add(regionIncrement);   for(int i=0; i < numRegions-1;i+)     BigInteger key = lowestKey.add(regionIncrement.multiply(BigInteger.valueOf(i);     byte b = String.format("%016x", key).getBytes();  

31、;   splitsi = b;      return splits; 1.2 Row KeyHBase中row key用来检索表中的记录，支持以下三种方式：· 通过单个row key访问：即按照某个row key键值进行get操作；· 通过row key的range进行scan：即通过设置startRowKey和endRowKey，在这个范围内进行扫描；· 全表扫描：即直接扫描整张表中所有行记录。在HBase中，row key可以是任意字符串，最大长度64KB，实际应用中一般为10100by

32、tes，存为byte字节数组，一般设计成定长的。row key是按照字典序存储，因此，设计row key时，要充分利用这个排序特点，将经常一起读取的数据存储到一块，将最近可能会被访问的数据放在一块。举个例子：如果最近写入HBase表中的数据是最可能被访问的，可以考虑将时间戳作为row key的一部分，由于是字典序排序，所以可以使用Long.MAX_VALUE timestamp作为row key，这样能保证新写入的数据在读取时可以被快速命中。1.3 Column Family不要在一张表里定义太多的column family。目前Hbase并不能很好的处理超过23个column family的

33、表。因为某个column family在flush的时候，它邻近的column family也会因关联效应被触发flush，最终导致系统产生更多的I/O。感兴趣的同学可以对自己的HBase集群进行实际测试，从得到的测试结果数据验证一下。1.4 In Memory创建表的时候，可以通过HColumnDescriptor.setInMemory(true)将表放到RegionServer的缓存中，保证在读取的时候被cache命中。1.5 Max Version创建表的时候，可以通过HColumnDescriptor.setMaxVersions(int maxVersions)设置表中数

34、据的最大版本，如果只需要保存最新版本的数据，那么可以设置setMaxVersions(1)。1.6 Time To Live创建表的时候，可以通过HColumnDescriptor.setTimeToLive(int timeToLive)设置表中数据的存储生命期，过期数据将自动被删除，例如如果只需要存储最近两天的数据，那么可以设置setTimeToLive(2 * 24 * 60 * 60)。1.7 Compact & Split在HBase中，数据在更新时首先写入WAL 日志(HLog)和内存(MemStore)中，MemStore中的数据是排序的，当MemStore累计到一定阈值

35、时，就会创建一个新的MemStore，并且将老的MemStore添加到flush队列，由单独的线程flush到磁盘上，成为一个StoreFile。于此同时， 系统会在zookeeper中记录一个redo point，表示这个时刻之前的变更已经持久化了(minor compact)。StoreFile是只读的，一旦创建后就不可以再修改。因此Hbase的更新其实是不断追加的操作。当一个Store中的StoreFile达到一定的阈值后，就会进行一次合并(major compact)，将对同一个key的修改合并到一起，形成一个大的StoreFile，当StoreFile的大小达到一定阈值后，又会对 S

36、toreFile进行分割(split)，等分为两个StoreFile。由于对表的更新是不断追加的，处理读请求时，需要访问Store中全部的StoreFile和MemStore，将它们按照row key进行合并，由于StoreFile和MemStore都是经过排序的，并且StoreFile带有内存中索引，通常合并过程还是比较快的。实际应用中，可以考虑必要时手动进行major compact，将同一个row key的修改进行合并形成一个大的StoreFile。同时，可以将StoreFile设置大些，减少split的发生。2. 写表操作2.1 多HTable并发写创建多个HTable客户端用于写操作

37、，提高写数据的吞吐量，一个例子：12345678static final Configuration conf = HBaseConfiguration.create(); static final String table_log_name = “user_log”; wTableLog = new HTabletableN; for (int i = 0; i < tableN; i+)     wTableLogi = new HTable(conf, table_log_name);     wTab

38、leLogi.setWriteBufferSize(5 * 1024 * 1024); /5MB     wTableLogi.setAutoFlush(false); 2.2 HTable参数设置2.2.1 Auto Flush通过调用HTable.setAutoFlush(false)方法可以将HTable写客户端的自动flush关闭，这样可以批量写入数据到HBase，而不是有一条put就执行一次更新，只有当put填满客户端写缓存时，才实际向HBase服务端发起写请求。默认情况下auto flush是开启的。 Write Buffer通过调用HTab

39、le.setWriteBufferSize(writeBufferSize)方法可以设置HTable客户端的写buffer大小，如果新设置的buffer小于当前写buffer中的数据时，buffer将会被flush到服务端。其中，writeBufferSize的单位是byte字节数，可以根据实际写入数据量的多少来设置该值。 WAL Flag在HBae中，客户端向集群中的RegionServer提交数据时（Put/Delete操作），首先会先写WAL（Write Ahead Log）日志（即HLog，一个RegionServer上的所有Region共享一个HLog），只有当WAL日志写成功后，再

40、接着写MemStore，然后客户端被通知提交数据成功；如果写WAL日志失败，客户端则被通知提交失败。这样做的好处是可以做到RegionServer宕机后的数据恢复。因此，对于相对不太重要的数据，可以在Put/Delete操作时，通过调用Put.setWriteToWAL(false)或Delete.setWriteToWAL(false)函数，放弃写WAL日志，从而提高数据写入的性能。值得注意的是：谨慎选择关闭WAL日志，因为这样的话，一旦RegionServer宕机，Put/Delete的数据将会无法根据WAL日志进行恢复。2.3 批量写通过调用HTable.put(Put)方法可以将一个指

41、定的row key记录写入HBase，同样HBase提供了另一个方法：通过调用HTable.put(List<Put>)方法可以将指定的row key列表，批量写入多行记录，这样做的好处是批量执行，只需要一次网络I/O开销，这对于对数据实时性要求高，网络传输RTT高的情景下可能带来明显的性能提升。2.4 多线程并发写在客户端开启多个HTable写线程，每个写线程负责一个HTable对象的flush操作，这样结合定时flush和写buffer（writeBufferSize），可以既保证在数据量小的时候，数据可以在较短时间内被flush（如1秒内），同时又保证在数据量大的时候，写bu

42、ffer一满就及时进行flush。下面给个具体的例子：12345678910111213141516171819202122for (int i = 0; i < threadN; i+)     Thread th = new Thread()         public void run()             while (true) &#

43、160;               try                     sleep(1000); /1 second           

44、;       catch (InterruptedException e)                     e.printStackTrace();                

45、                                  synchronized (wTableLogi)             

46、60;       try                         wTableLogi.flushCommits();              &#

47、160;       catch (IOException e)                         e.printStackTrace();             

48、                                                    

49、60;            th.setDaemon(true);     th.start(); 3. 读表操作3.1 多HTable并发读创建多个HTable客户端用于读操作，提高读数据的吞吐量，一个例子：1234567static final Configuration conf = HBaseConfiguration.create(); static final String table_log_name = “user_log”; rTabl

50、eLog = new HTabletableN; for (int i = 0; i < tableN; i+)     rTableLogi = new HTable(conf, table_log_name);     rTableLogi.setScannerCaching(50); 3.2 HTable参数设置 Scanner Caching通过调用HTable.setScannerCaching(int scannerCaching)可以设置HBase scanner一次从服务端抓取的数据条数，默认

51、情况下一次一条。通过将此值设置成一个合理的值，可以减少scan过程中next()的时间开销，代价是scanner需要通过客户端的内存来维持这些被cache的行记录。 Scan Attribute Selectionscan时指定需要的Column Family，可以减少网络传输数据量，否则默认scan操作会返回整行所有Column Family的数据。 Close ResultScanner通过scan取完数据后，记得要关闭ResultScanner，否则RegionServer可能会出现问题（对应的Server资源无法释放）。3.3 批量读通过调用HTable.get(Get)方法可以根据一

52、个指定的row key获取一行记录，同样HBase提供了另一个方法：通过调用HTable.get(List)方法可以根据一个指定的row key列表，批量获取多行记录，这样做的好处是批量执行，只需要一次网络I/O开销，这对于对数据实时性要求高而且网络传输RTT高的情景下可能带来明显的性能提升。3.4 多线程并发读在客户端开启多个HTable读线程，每个读线程负责通过HTable对象进行get操作。下面是一个多线程并发读取HBase，获取店铺一天内各分钟PV值的例子：12345678910111213141516171819202122232425262728293031323334353637

53、3839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146public class DataReaderServer  

54、;    /获取店铺一天内各分钟PV值的入口函数      public static ConcurrentHashMap getUnitMinutePV(long uid, long startStamp, long endStamp)          long min = startStamp;          int

55、count = (int)(endStamp - startStamp) / (60*1000);          List lst = new ArrayList();          for (int i = 0; i <= count; i+)             min = s

56、tartStamp + i * 60 * 1000;             lst.add(uid + "_" + min);                    return parallelBatchMinutePV(lst);    

57、60;        /多线程并发查询，获取分钟PV值 private static ConcurrentHashMap parallelBatchMinutePV(List lstKeys)         ConcurrentHashMap hashRet = new ConcurrentHashMap();         int parallel = 3; &

58、#160;       List<List<String>> lstBatchKeys  = null;         if (lstKeys.size() < parallel )             lstBatchKeys  = new ArrayList<Li

59、st<String>>(1);             lstBatchKeys.add(lstKeys);                  else             ls

60、tBatchKeys  = new ArrayList<List<String>>(parallel);             for(int i = 0; i < parallel; i+  )                 List lst = new Arra

61、yList();                 lstBatchKeys.add(lst);                            for(int i = 0 ;

62、 i < lstKeys.size() ; i + )                 lstBatchKeys.get(i%parallel).add(lstKeys.get(i);                       &#

63、160;         List >> futures = new ArrayList >>(5);           ThreadFactoryBuilder builder = new ThreadFactoryBuilder();         builder.setNameFormat(&q

64、uot;ParallelBatchQuery");         ThreadFactory factory = builder.build();         ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(lstBatchKeys.size(), factory);    

65、60;      for(List keys : lstBatchKeys)             Callable< ConcurrentHashMap > callable = new BatchMinutePVCallable(keys);             FutureT

66、ask< ConcurrentHashMap > future = (FutureTask< ConcurrentHashMap >) executor.submit(callable);             futures.add(future);                  exe

67、cutor.shutdown();           / Wait for all the tasks to finish         try           boolean stillRunning = !executor.awaitTermination(     

68、          5000000, TimeUnit.MILLISECONDS);           if (stillRunning)             try          

69、;       executor.shutdownNow();              catch (Exception e)                 / TODO Auto-generated catch block  

70、0;              e.printStackTrace();                                  catch (Int

71、erruptedException e)           try               Thread.currentThread().interrupt();            catch (Exception e1)   &

72、#160;         / TODO Auto-generated catch block             e1.printStackTrace();                    

73、60;         / Look for any exception         for (Future f : futures)           try              

74、60;if(f.get() != null)                                  hashRet.putAll(ConcurrentHashMap)f.get();        

75、                   catch (InterruptedException e)             try                

76、;  Thread.currentThread().interrupt();              catch (Exception e1)                 / TODO Auto-generated catch block     

77、60;           e1.printStackTrace();                         catch (ExecutionException e)        

78、0;    e.printStackTrace();                               return hashRet;           /一个线程批量查询，获取

79、分钟PV值     protected static ConcurrentHashMap getBatchMinutePV(List lstKeys)         ConcurrentHashMap hashRet = null;         List lstGet = new ArrayList();        &

80、#160;String splitValue = null;         for (String s : lstKeys)             splitValue = s.split("_");             long uid = Long

81、.parseLong(splitValue0);             long min = Long.parseLong(splitValue1);             byte key = new byte16;            &#

82、160;Bytes.putLong(key, 0, uid);             Bytes.putLong(key, 8, min);             Get g = new Get(key);             g.

83、addFamily(fp);             lstGet.add(g);                  Result res = null;         try      

84、       res = tableMinutePVrand.nextInt(tableN).get(lstGet);          catch (IOException e1)             logger.error("tableMinutePV exception, e=" + e1.getStackTrace();