n加1网站建设,要想提高网站排名应该如何做,质监站网址,网站推广的名词解释1. 表的设计
1.1 Pre-Creating Regions
默认情况下#xff0c;在创建HBase表的时候会自动创建一个region分区#xff0c;当导入数据的时候#xff0c;所有的HBase客户端都向这一个region写数据#xff0c;直到这个region足够大了才进行切分。一种可以加快批量写入速度的方…1. 表的设计
1.1 Pre-Creating Regions
默认情况下在创建HBase表的时候会自动创建一个region分区当导入数据的时候所有的HBase客户端都向这一个region写数据直到这个region足够大了才进行切分。一种可以加快批量写入速度的方法是通过预先创建一些空的regions这样当数据写入HBase时会按照region分区情况在集群内做数据的负载均衡。 有关预分区详情参见Table Creation: Pre-Creating Regions下面是一个例子
public static boolean createTable(HBaseAdmin admin, HTableDescriptor table, byte[][] splits)
throws IOException {try {admin.createTable(table, splits);return true;} catch (TableExistsException e) {logger.info(table table.getNameAsString() already exists);// the table already exists...return false; }
}public static byte[][] getHexSplits(String startKey, String endKey, int numRegions) { //start:001,endkey:100,10region [001,010]
[011,020]byte[][] splits new byte[numRegions-1][];BigInteger lowestKey new BigInteger(startKey, 16);BigInteger highestKey new BigInteger(endKey, 16);BigInteger range highestKey.subtract(lowestKey);BigInteger regionIncrement range.divide(BigInteger.valueOf(numRegions));lowestKey lowestKey.add(regionIncrement);for(int i0; i numRegions-1;i) {BigInteger key lowestKey.add(regionIncrement.multiply(BigInteger.valueOf(i)));byte[] b String.format(%016x, key).getBytes();splits[i] b;}return splits;
}1.2 Row Key
HBase中row key用来检索表中的记录支持以下三种方式
通过单个row key访问即按照某个row key键值进行get操作通过row key的range进行scan即通过设置startRowKey和endRowKey在这个范围内进行扫描全表扫描即直接扫描整张表中所有行记录。
在HBase中row key可以是任意字符串最大长度64KB实际应用中一般为10~100bytes存为byte[]字节数组一般设计成定长的。 row key是按照字典序存储因此设计row key时要充分利用这个排序特点将经常一起读取的数据存储到一块将最近可能会被访问的数据放在一块。 举个例子如果最近写入HBase表中的数据是最可能被访问的可以考虑将时间戳作为row key的一部分由于是字典序排序所以可以使用Long.MAX_VALUE - timestamp作为row key这样能保证新写入的数据在读取时可以被快速命中。 Rowkey规则 1、越小越好 2、Rowkey的设计是要根据实际业务来 3、散列性 a)取反 001 002 100 200 b)Hash
1.3 Column Family
不要在一张表里定义太多的column family。目前Hbase并不能很好的处理超过2~3个column family的表。因为某个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)设置表中数据的最大版本如果只需要保存最新版本的数据那么可以设置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累计到一定阈值时就会创建一个新的MemStore并且将老的MemStore添加到flush队列由单独的线程flush到磁盘上成为一个StoreFile。于此同时 系统会在zookeeper中记录一个redo point表示这个时刻之前的变更已经持久化了(minor compact)。 StoreFile是只读的一旦创建后就不可以再修改。因此Hbase的更新其实是不断追加的操作。当一个Store中的StoreFile达到一定的阈值后就会进行一次合并(major compact)将对同一个key的修改合并到一起形成一个大的StoreFile当StoreFile的大小达到一定阈值后又会对 StoreFile进行分割(split)等分为两个StoreFile。 由于对表的更新是不断追加的处理读请求时需要访问Store中全部的StoreFile和MemStore将它们按照row key进行合并由于StoreFile和MemStore都是经过排序的并且StoreFile带有内存中索引通常合并过程还是比较快的。 实际应用中可以考虑必要时手动进行major compact将同一个row key的修改进行合并形成一个大的StoreFile。同时可以将StoreFile设置大些减少split的发生。
hbase为了防止小文件被刷到磁盘的menstore过多以保证保证查询效率hbase需要在必要的时候将这些小的store file合并成相对较大的store file这个过程就称之为compaction。在hbase中主要存在两种类型的compactionminor compaction和major compaction。 minor compaction:的是较小、很少文件的合并。 major compaction 的功能是将所有的store file合并成一个触发major compaction的可能条件有major_compact 命令、majorCompact() API、region server自动运行相关参数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 这个范围。
1、关闭自动major compaction 2、手动编程major compaction
Timer类contab
minor compaction的运行机制要复杂一些它由一下几个参数共同决定
hbase.hstore.compaction.min :默认值为 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 youngerminor compaction总是从older store file开始选择2. 写表操作
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); //5MBwTableLog[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操作首先会先写WALWrite 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)方法可以将指定的row key列表批量写入多行记录这样做的好处是批量执行只需要一次网络I/O开销这对于对数据实时性要求高网络传输RTT高的情景下可能带来明显的性能提升。 2.4 多线程并发写 在客户端开启多个HTable写线程每个写线程负责一个HTable对象的flush操作这样结合定时flush和写bufferwriteBufferSize可以既保证在数据量小的时候数据可以在较短时间内被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
hbase.client.scanner.caching配置项可以设置HBase scanner一次从服务端抓取的数据条数默认情况下一次一条。通过将其设置成一个合理的值可以减少scan过程中next()的时间开销代价是scanner需要通过客户端的内存来维持这些被cache的行记录。 有三个地方可以进行配置1在HBase的conf配置文件中进行配置2通过调用HTable.setScannerCaching(int scannerCaching)进行配置3通过调用Scan.setCaching(int caching)进行配置。三者的优先级越来越高。
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 ConcurrentHashMapString, String getUnitMinutePV(long uid, long startStamp, long endStamp){long min startStamp;int count (int)((endStamp - startStamp) / (60*1000));ListString lst new ArrayListString();for (int i 0; i count; i) {min startStamp i * 60 * 1000;lst.add(uid _ min);}return parallelBatchMinutePV(lst);}//多线程并发查询获取分钟PV值
private static ConcurrentHashMapString, String parallelBatchMinutePV(ListString lstKeys){ConcurrentHashMapString, String hashRet new ConcurrentHashMapString, String();int parallel 3;ListListString lstBatchKeys null;if (lstKeys.size() parallel ){lstBatchKeys new ArrayListListString(1);lstBatchKeys.add(lstKeys);}else{lstBatchKeys new ArrayListListString(parallel);for(int i 0; i parallel; i ){ListString lst new ArrayListString();lstBatchKeys.add(lst);}for(int i 0 ; i lstKeys.size() ; i ){lstBatchKeys.get(i%parallel).add(lstKeys.get(i));}}ListFuture ConcurrentHashMapString, String futures new ArrayListFuture ConcurrentHashMapString, String (5);ThreadFactoryBuilder builder new ThreadFactoryBuilder();builder.setNameFormat(ParallelBatchQuery);ThreadFactory factory builder.build();ThreadPoolExecutor executor (ThreadPoolExecutor) Executors.newFixedThreadPool(lstBatchKeys.size(), factory);for(ListString keys : lstBatchKeys){Callable ConcurrentHashMapString, String callable new BatchMinutePVCallable(keys);FutureTask ConcurrentHashMapString, String future (FutureTask ConcurrentHashMapString, String ) executor.submit(callable);futures.add(future);}executor.shutdown();// Wait for all the tasks to finishtry {boolean stillRunning !executor.awaitTermination(5000000, TimeUnit.MILLISECONDS);if (stillRunning) {try {executor.shutdownNow();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}}} catch (InterruptedException e) {try {Thread.currentThread().interrupt();} catch (Exception e1) {// TODO Auto-generated catch blocke1.printStackTrace();}}// Look for any exceptionfor (Future f : futures) {try {if(f.get() ! null){hashRet.putAll((ConcurrentHashMapString, String)f.get());}} catch (InterruptedException e) {try {Thread.currentThread().interrupt();} catch (Exception e1) {// TODO Auto-generated catch blocke1.printStackTrace();}} catch (ExecutionException e) {e.printStackTrace();}}return hashRet;}//一个线程批量查询获取分钟PV值protected static ConcurrentHashMapString, String getBatchMinutePV(ListString lstKeys){ConcurrentHashMapString, String hashRet null;ListGet lstGet new ArrayListGet();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 ConcurrentHashMapString, 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 CallableConcurrentHashMapString, String{private ListString keys;public BatchMinutePVCallable(ListString lstKeys ) {this.keys lstKeys;}public ConcurrentHashMapString, String call() throws Exception {return DataReadServer.getBatchMinutePV(keys);}
}3.5 缓存查询结果
对于频繁查询HBase的应用场景可以考虑在应用程序中做缓存当有新的查询请求时首先在缓存中查找如果存在则直接返回不再查询HBase否则对HBase发起读请求查询然后在应用程序中将查询结果缓存起来。至于缓存的替换策略可以考虑LRU等常用的策略。
3.6 Blockcache
HBase上Regionserver的内存分为两个部分一部分作为Memstore主要用来写另外一部分作为BlockCache主要用于读。 写请求会先写入MemstoreRegionserver会给每个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设大些比如设置BlockCache0.4Memstore0.39以加大缓存的命中率。 有关BlockCache机制请参考这里HBase的Block cacheHBase的blockcache机制hbase中的缓存的计算与使用。
HTable和HTablePool使用注意事项 HTable和HTablePool都是HBase客户端API的一部分可以使用它们对HBase表进行CRUD操作。下面结合在项目中的应用情况对二者使用过程中的注意事项做一下概括总结。
Configuration conf HBaseConfiguration.create();
try (Connection connection ConnectionFactory.createConnection(conf)) {try (Table table connection.getTable(TableName.valueOf(tablename)) {// use table as needed, the table returned is lightweight}
}HTable
HTable是HBase客户端与HBase服务端通讯的Java API对象客户端可以通过HTable对象与服务端进行CRUD操作增删改查。它的创建很简单
Configuration conf HBaseConfiguration.create();
HTable table new HTable(conf, tablename);
//TODO CRUD Operation……HTable使用时的一些注意事项
1. 规避HTable对象的创建开销
因为客户端创建HTable对象后需要进行一系列的操作检查.META.表确认指定名称的HBase表是否存在表是否有效等等整个时间开销比较重可能会耗时几秒钟之长因此最好在程序启动时一次性创建完成需要的HTable对象如果使用Java API一般来说是在构造函数中进行创建程序启动后直接重用。
2. HTable对象不是线程安全的
HTable对象对于客户端读写数据来说不是线程安全的因此多线程时要为每个线程单独创建复用一个HTable对象不同对象间不要共享HTable对象使用特别是在客户端auto flash被置为false时由于存在本地write buffer可能导致数据不一致。
3. HTable对象之间共享Configuration
HTable对象共享Configuration对象这样的好处在于
共享ZooKeeper的连接每个客户端需要与ZooKeeper建立连接查询用户的table regions位置这些信息可以在连接建立后缓存起来共享使用共享公共的资源客户端需要通过ZooKeeper查找-ROOT-和.META.表这个需要网络传输开销客户端缓存这些公共资源后能够减少后续的网络传输开销加快查找过程速度。 因此与以下这种方式相比
HTable table1 new HTable(table1);
HTable table2 new HTable(table2);下面的方式更有效些
Configuration conf HBaseConfiguration.create();
HTable table1 new HTable(conf, table1);
HTable table2 new HTable(conf, table2);备注即使是高负载的多线程程序也并没有发现因为共享Configuration而导致的性能问题如果你的实际情况中不是如此那么可以尝试不共享Configuration。
HTablePool
HTablePool可以解决HTable存在的线程不安全问题同时通过维护固定数量的HTable对象能够在程序运行期间复用这些HTable资源对象。 Configuration conf HBaseConfiguration.create(); HTablePool pool new HTablePool(conf, 10);
1. HTablePool可以自动创建HTable对象而且对客户端来说使用上是完全透明的可以避免多线程间数据并发修改问题。
2. HTablePool中的HTable对象之间是公用Configuration连接的能够可以减少网络开销。
HTablePool的使用很简单每次进行操作前通过HTablePool的getTable方法取得一个HTable对象然后进行put/get/scan/delete等操作最后通过HTablePool的putTable方法将HTable对象放回到HTablePool中。 下面是个使用HTablePool的简单例子
public void createUser(String username, String firstName, String lastName, String email, String password, String roles) throws IOException {HTable table rm.getTable(UserTable.NAME);Put put new Put(Bytes.toBytes(username));put.add(UserTable.DATA_FAMILY, UserTable.FIRSTNAME,Bytes.toBytes(firstName));put.add(UserTable.DATA_FAMILY, UserTable.LASTNAME,Bytes.toBytes(lastName));put.add(UserTable.DATA_FAMILY, UserTable.EMAIL, Bytes.toBytes(email));put.add(UserTable.DATA_FAMILY, UserTable.CREDENTIALS,Bytes.toBytes(password));put.add(UserTable.DATA_FAMILY, UserTable.ROLES, Bytes.toBytes(roles));table.put(put);table.flushCommits();rm.putTable(table);
}Hbase和DBMS比较
查询数据不灵活 1、不能使用column之间过滤查询 2、不支持全文索引。使用ES和hbase整合完成全文搜索。 a)使用MR批量读取hbase中的数据在ES里面建立索引no store之保存rowkey的值。 b)根据关键词从索引中搜索到rowkey分页 c)根据rowkey从hbase查询所有数据
