大数据——HBase原理

最新推荐文章于 2024-07-28 23:55:21 发布
最新推荐文章于 2024-07-28 23:55:21 发布
阅读量1.2k 收藏 24
点赞数 8
分类专栏： 大数据 文章标签： 大数据 hbase 数据库
未经同意窃取和转载我的内容，如果涉及到权益问题，后果自负！
本文链接：https://blog.csdn.net/weixin_41605937/article/details/140739838
版权

摘要

HBase 是一个开源的、非关系型的分布式数据库系统，主要用于存储海量的结构化和半结构化数据。它是基于谷歌的 Bigtable 论文实现的，运行在 Hadoop 分布式文件系统（HDFS）之上，并且可以与 Hadoop 生态系统的其他组件无缝集成。

HBase 的设计目标是提供高可扩展性、实时读写和随机访问能力，这使其特别适合于需要快速处理和查询大数据集的应用场景。它采用行键（Row Key）作为主键，并使用列族（Column Family）来组织数据，数据在物理上按照行键的顺序存储，支持范围查询。

HBase 提供了强大的数据模型，支持版本控制和稀疏存储，同时还支持通过 MapReduce 进行批处理操作。它具有自动分片、负载均衡和故障恢复能力，确保了系统的高可用性和可靠性。HBase 常用于需要高吞吐量和低延迟的应用，如实时分析、日志处理和用户行为跟踪等。

HBase 的查询语言类似于 SQL，但更适合大规模分布式数据存储和处理。它与传统的关系数据库不同，不支持复杂的关系操作，如 JOIN 和事务处理，但通过灵活的设计和高效的存储模型，HBase 在大数据场景下表现出色。

1. HBase基础概念

HBase是一种分布式、可扩展、支持海量数据存储的 NoSQL 数据库。 逻辑上，HBase的数据模型同关系型数据库很类似，数据存储在一张表中，有行有列。但从HBase的底层物理存储结构（K-V）来看，HBase更像是一个multi-dimensional map。

HBase被称为内存数据库，主要是因为它的数据存储和读取主要依赖于内存，这使得HBase能够提供高性能的随机读写能力。 具体来说，HBase具备以下几个核心特性：

  1. HBase使用内存作为主要的数据缓存，大部分常用数据都被存储在内存中，这样可以大幅度提高数据读取的速度；
  2. HBase支持数据的实时随机访问，这是因为HBase的数据模型是基于列的，列数据存储在一起，可以快速定位到具体的数据；
  3. HBase设计了高效的写入策略，通过Write-Ahead Log (WAL)机制，数据首先被写入到内存中，然后再同步到硬盘，这样可以大幅度提高写入的效率。

2. HBase系统架构

Region Server：Region Server为 Region的管理者，其实现类为HRegionServer，主要作用如下:

  1. 对于数据的操作：get, put, delete；
  2. 对于Region的操作：splitRegion、compactRegion。

Master：Master是所有Region Server的管理者，其实现类为HMaster，主要作用如下：

  1. 对于表的操作：create, delete, alter
  2. 对于RegionServer的操作：分配regions到每个RegionServer，监控每个RegionServer的状态，负载均衡和故障转移。

Zookeeper：HBase通过Zookeeper来做Master的高可用、RegionServer的监控、元数据的入口以及集群配置的维护等工作。

HDFS：HDFS为HBase提供最终的底层数据存储服务，同时为HBase提供高可用的支持。

StoreFile：保存实际数据的物理文件，StoreFile以HFile的形式存储在HDFS上。每个Store会有一个或多个StoreFile（HFile），数据在每个StoreFile中都是有序的。

MemStore：写缓存，由于HFile中的数据要求是有序的，所以数据是先存储在MemStore中，排好序后，等到达刷写时机才会刷写到HFile，每次刷写都会形成一个新的HFile。

WAL：由于数据要经MemStore排序后才能刷写到HFile，但把数据保存在内存中会有很高的概率导致数据丢失，为了解决这个问题，数据会先写在一个叫做Write-Ahead logfile的文件中，然后再写入MemStore中。所以在系统出现故障的时候，数据可以通过这个日志文件重建。

3. HBase数据模型

3.1. HBase逻辑结构

3.2. HBase物理结构

  1. Name Space：命名空间，类似于关系型数据库的DatabBase概念沐，与mysql的数据库的概念类似，每个命名空间下有多个表。HBase有两个自带的命名空间，分别是hbase和default，hbase中存放的是HBase内置的表，default表是用户默认使用的命名空间。
  2. Region：类似于关系型数据库的表概念。不同的是，HBase定义表时只需要声明列族即可，不需要声明具体的列。这意味着，往HBase写入数据时，字段可以动态、按需指定。因此和关系型数据库相比，HBase能够轻松应对字段变更的场景。
  3. Row：HBase表中的每行数据都由一个RowKey和多个Column（列）组成，数据是按照RowKey的字典顺序存储的，并且查询数据时只能根据RowKey进行检索，所以RowKey的设计十分重要。
  4. Column：HBase中的每个列都由Column Family(列族)和Column Qualifier（列限定符）进行限定，例如info：name，info：age。建表时，只需指明列族，而列限定符无需预先定义。
  5. Time Stamp：用于标识数据的不同版本（version），每条数据写入时，如果不指定时间戳，系统会自动为其加上该字段，其值为写入HBase的时间。
  6. Cell：由{rowkey, column Family：column Qualifier, time Stamp} 唯一确定的单元。cell中的数据是没有类型的，全部是字节码形式存贮。

4. HBase的函数API

4.1. HBase基本函数

# 进入HBase客户端命令行
bin/hbase shell

# 查看当前数据库中有哪些表
hbase(main):002:0> list

# 创建表
hbase(main):002:0> create 'student','info'

# 插入数据
hbase(main):003:0> put 'student','1001','info:sex','male'
hbase(main):004:0> put 'student','1001','info:age','18'

# 扫描查看表数据
hbase(main):008:0> scan 'student'
hbase(main):009:0> scan 'student',{STARTROW => '1001', STOPROW  => '1001'}
hbase(main):010:0> scan 'student',{STARTROW => '1001'}

# 查看表结构
hbase(main):011:0> describe ‘student’

# 更新指定字段的数据
hbase(main):012:0> put 'student','1001','info:name','Nick'
hbase(main):013:0> put 'student','1001','info:age','100'

# 查看“指定行”或“指定列族:列”的数据
hbase(main):014:0> get 'student','1001'
hbase(main):015:0> get 'student','1001','info:name'

# 统计表数据行数
hbase(main):021:0> count 'student'

# 删除某rowkey的全部数据：
hbase(main):016:0> deleteall 'student','1001'

# 删除某rowkey的某一列数据：
hbase(main):017:0> delete 'student','1002','info:sex'

# 清空表数据 清空表student表
hbase(main):018:0> truncate 'student'

# 删除表，首先需要先让该表为disable状态：
hbase(main):019:0> disable 'student'

# 然后才能drop这个表：
hbase(main):020:0> drop 'student'

如果直接drop表，会报错：ERROR: Table student is enabled. Disable it first.

变更表信息，将info列族中的数据存放3个版本：
hbase(main):022:0> alter 'student',{NAME=>'info',VERSIONS=>3}
hbase(main):022:0> get 'student','1001',{COLUMN=>'info:name',VERSIONS=>3}

4.2. HBase基本API

DDL语句（表级别操作）：

  1. 判断表是否存在
  2. 创建表
  3. 创建命名空间
  4. 删除表

DML语句（数据级别操作）：

  1. 插入数据
  2. 查询数据
  3. 修改数据
  4. 删除数据

表的操作对象是HBaseAdmin admin

public static Configuration conf;
static{
	//使用HBaseConfiguration的单例方法实例化
	conf = HBaseConfiguration.create();
  conf.set("hbase.zookeeper.quorum", "192.166.9.102");
  conf.set("hbase.zookeeper.property.clientPort", "2181");
}

public static boolean isTableExist(String tableName) throws MasterNotRunningException,
   ZooKeeperConnectionException, IOException{
   //在HBase中管理、访问表需要先创建HBaseAdmin对象
   //Connection connection = ConnectionFactory.createConnection(conf);
   //HBaseAdmin admin = (HBaseAdmin) connection.getAdmin();
	 HBaseAdmin admin = new HBaseAdmin(conf);
	 return admin.tableExists(tableName);
}
public static void createTable(String tableName, String... columnFamily) throws
 MasterNotRunningException, ZooKeeperConnectionException, IOException{
	HBaseAdmin admin = new HBaseAdmin(conf);
	//判断表是否存在
	if(isTableExist(tableName)){
		System.out.println("表" + tableName + "已存在");
		//System.exit(0);
	}else{
		//创建表属性对象,表名需要转字节
		HTableDescriptor descriptor = new HTableDescriptor(TableName.valueOf(tableName));
		//创建多个列族
		for(String cf : columnFamily){
			descriptor.addFamily(new HColumnDescriptor(cf));
		}
		//根据对表的配置，创建表
		admin.createTable(descriptor);
		System.out.println("表" + tableName + "创建成功！");
	}
}
public static void dropTable(String tableName) throws MasterNotRunningException,
 ZooKeeperConnectionException, IOException{
	HBaseAdmin admin = new HBaseAdmin(conf);
	if(isTableExist(tableName)){
    # 先disbale 在能实现删除表
		admin.disableTable(tableName);
		admin.deleteTable(tableName);
		System.out.println("表" + tableName + "删除成功！");
	}else{
		System.out.println("表" + tableName + "不存在！");
	}
}

数据操作对象是 HTable hTable

public static void addRowData(String tableName, String rowKey, String columnFamily, String
 column, String value) throws IOException{
	//创建HTable对象 就是操作的对象
	HTable hTable = new HTable(conf, tableName);
	//向表中插入数据
	Put put = new Put(Bytes.toBytes(rowKey));
	//向Put对象中组装数据
	put.add(Bytes.toBytes(columnFamily), Bytes.toBytes(column), Bytes.toBytes(value));
	hTable.put(put);
	hTable.close();
	System.out.println("插入数据成功");
}
public static void deleteMultiRow(String tableName, String... rows) throws IOException{
	HTable hTable = new HTable(conf, tableName);
	List<Delete> deleteList = new ArrayList<Delete>();
	for(String row : rows){
		Delete delete = new Delete(Bytes.toBytes(row));
		deleteList.add(delete);
	}
	hTable.delete(deleteList);
	hTable.close();
}
public static void getAllRows(String tableName) throws IOException{
	HTable hTable = new HTable(conf, tableName);
	//得到用于扫描region的对象
	Scan scan = new Scan();
	//使用HTable得到resultcanner实现类的对象
	ResultScanner resultScanner = hTable.getScanner(scan);
	for(Result result : resultScanner){
		Cell[] cells = result.rawCells();
		for(Cell cell : cells){
			//得到rowkey
			System.out.println("行键:" + Bytes.toString(CellUtil.cloneRow(cell)));
			//得到列族
			System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
			System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
			System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
		}
	}
public static void getRow(String tableName, String rowKey) throws IOException{
  	 HTable table = new HTable(conf, tableName);
  	Get get = new Get(Bytes.toBytes(rowKey));
  	//get.setMaxVersions();显示所有版本
    //get.setTimeStamp();显示指定时间戳的版本
  	Result result = table.get(get);
  	for(Cell cell : result.rawCells()){
  		System.out.println("行键:" + Bytes.toString(result.getRow()));
  		System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
  		System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
  		System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
  		System.out.println("时间戳:" + cell.getTimestamp());
  	}
}
public static void getRowQualifier(String tableName, String rowKey, String family, String
 qualifier) throws IOException{
  	HTable table = new HTable(conf, tableName);
  	Get get = new Get(Bytes.toBytes(rowKey));
  	get.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
  	Result result = table.get(get);
  	for(Cell cell : result.rawCells()){
  		System.out.println("行键:" + Bytes.toString(result.getRow()));
  		System.out.println("列族" + Bytes.toString(CellUtil.cloneFamily(cell)));
  		System.out.println("列:" + Bytes.toString(CellUtil.cloneQualifier(cell)));
  		System.out.println("值:" + Bytes.toString(CellUtil.cloneValue(cell)));
    }
}

5. HBase的写流程（与Rocketmq写类似）

写流程：

  1. Client先访问zookeeper，获取hbase:meta表位于哪个Region Server。
  2. 访问对应的Region Server，获取hbase:meta表，根据读请求的namespace:table/rowkey，查询出目标数据位于哪个Region Server中的哪个Region中。并将该table的region信息以及meta表的位置信息缓存在客户端的meta cache，方便下次访问。
  3. 与目标Region Server进行通讯；
  4. 将数据顺序写入（追加）到WAL；
  5. 将数据写入对应的MemStore，数据会在MemStore进行排序；
  6. 向客户端发送ack；
  7. 等达到MemStore的刷写时机后，将数据刷写到HFile。

6. HBase的读流程（读比写慢数据库）

HBase的读写流程是先把磁盘和内存的数据一起读区出来，然后在进行的merge。

读流程

  1. Client先访问zookeeper，获取hbase:meta表位于哪个Region Server。
  2. 访问对应的Region Server，获取hbase:meta表，根据读请求的namespace:table/rowkey，查询出目标数据位于哪个Region Server中的哪个Region中。并将该table的region信息以及meta表的位置信息缓存在客户端的meta cache，方便下次访问。
  3. 与目标Region Server进行通讯；
  4. 分别在Block Cache（读缓存），MemStore和Store File（HFile）中查询目标数据，并将查到的所有数据进行合并。此处所有数据是指同一条数据的不同版本（time stamp）或者不同的类型（Put/Delete）。
  5. 将从文件中查询到的数据块（Block，HFile数据存储单元，默认大小为64KB）缓存到Block Cache。
  6. 将合并后的最终结果返回给客户端。

7. HBase的Flush流程（数据刷盘机制，与mysql的数据刷盘类似）

MemStore刷写时机：

  1. 当某个memstroe的大小达到了hbase.hregion.memstore.flush.size（默认值128M），其所在region的所有memstore都会刷写。当memstore的大小达到了 hbase.hregion.memstore.flush.size（默认值128M），*hbase.hregion.memstore.block.multiplier（默认值4）时，会阻止继续往该memstore写数据。
  2. 当region server中memstore的总大小达到 java_heapsize，*hbase.regionserver.global.memstore.size（默认值0.4）*hbase.regionserver.global.memstore.size.lower.limit（默认值0.95），
  3. region会按照其所有memstore的大小顺序（由大到小）依次进行刷写。直到region server中所有memstore的总大小减小到上述值以下。
  4. 当region server中memstore的总大小达到 java_heapsize ，*hbase.regionserver.global.memstore.size（默认值0.4）时，会阻止继续往所有的memstore写数据。
  5. 到达自动刷写的时间，也会触发memstore flush。自动刷新的时间间隔由该属性进行配置hbase.regionserver.optionalcacheflushinterval（默认1小时）。
  6. 当WAL文件的数量超过hbase.regionserver.max.logs，region会按照时间顺序依次进行刷写，直到WAL文件数量减小到hbase.regionserver.max.log以下（该属性名已经废弃，现无需手动设置，最大值为32）。

8. HBase的StoreFile Compact流程（小文件合并）

由于memstore每次刷写都会生成一个新的HFile，且同一个字段的不同版本（timestamp）和不同类型（Put/Delete）有可能会分布在不同的HFile中，因此查询时需要遍历所有的HFile。为了减少HFile的个数，以及清理掉过期和删除的数据，会进行StoreFile Compaction。

Compaction分为两种，分别是Minor Compaction和Major Compaction。Minor Compaction会将临近的若干个较小的HFile合并成一个较大的HFile，但不会清理过期和删除的数据。Major Compaction会将一个Store下的所有的HFile合并成一个大HFile，并且会清理掉过期和删除的数据。

9. HBase的Region切分流程（大文件拆分）

默认情况下，每个Table起初只有一个Region，随着数据的不断写入，Region会自动进行拆分。刚拆分时，两个子Region都位于当前的Region Server，但处于负载均衡的考虑，HMaster有可能会将某个Region转移给其他的Region Server。

Region Split时机：

  1. 当1个region中的某个Store下所有StoreFile的总大小超过hbase.hregion.max.filesize，该Region就会进行拆分（0.94版本之前）。
  2. 当1个region中的某个Store下所有StoreFile的总大小超过Min(R^2 * "hbase.hregion.memstore.flush.size",hbase.hregion.max.filesize")，该Region就会进行拆分，其中R为当前Region Server中属于该Table的个数（0.94版本之后）

10. HBase的数据删除流程

  1. 逻辑删除： HBase不会立即在物理存储上删除数据，而是采用逻辑删除的方式。当执行删除操作时，HBase会将一条特殊的删除标记（Tombstone）插入到相应的数据单元中。这个删除标记指示这个数据单元已被删除，并且会在数据保留的时间后清理掉。
  2. Major Compaction（主要合并）： HBase定期执行Major Compaction操作，它会合并和清理数据文件，删除标记和过期数据。Major Compaction将不再需要的数据清理掉，从而释放磁盘空间，并提高读取性能。
  3. Minor Compaction（次要合并）： 在Major Compaction之外，HBase还执行Minor Compaction，它用于合并较小的数据文件以优化存储布局，但不会清理删除标记。
  4. 删除标记的清理： 当Major Compaction执行时，HBase会检查数据单元中的删除标记，如果数据的所有版本都已被标记为删除，则在Major Compaction中清理掉这些数据。

需要注意的是，HBase的删除操作并不是实时的，而是通过Compaction过程逐步进行的。这意味着一条数据的删除标记可能会在Compaction之前存在一段时间，直到Compaction执行并将其清理。这种机制有助于保持HBase的高性能和高吞吐量，同时确保数据的持久性和一致性。总之，HBase通过逻辑删除和Compaction机制来处理数据的删除操作。删除数据会在逻辑上插入删除标记，而实际的物理清理会在Compaction过程中进行。这种机制可以平衡数据的删除和性能需求，确保数据的有效管理和存储。

11. HBase的优化设计

11.1. HBase的Master的高可用设计

在HBase中HMaster负责监控HRegionServer的生命周期，均衡RegionServer的负载，如果HMaster挂掉了，那么整个HBase集群将陷入不健康的状态，并且此时的工作状态并不会维持太久。所以HBase支持对HMaster的高可用配置。

关闭HBase集群（如果没有开启则跳过此步）
[xjl@hadoop102 hbase]$ bin/stop-hbase.sh

在conf目录下创建backup-masters文件
[xjl@hadoop102 hbase]$ touch conf/backup-masters

在backup-masters文件中配置高可用HMaster节点
[xjl@hadoop102 hbase]$ echo hadoop103 > conf/backup-masters

将整个conf目录scp到其他节点
[xjl@hadoop102 hbase]$ scp -r conf/ hadoop103:/opt/module/hbase/
[xjl@hadoop102 hbase]$ scp -r conf/ hadoop104:/opt/module/hbase/

打开页面测试查看

11.2. HBase的预分区设计

每一个region维护着StartRow与EndRow，如果加入的数据符合某个Region维护的RowKey范围，则该数据交给这个Region维护。那么依照这个原则，我们可以将数据所要投放的分区提前大致的规划好，以提高HBase性能。

# 手动设定预分区
Hbase> create 'staff1','info','partition1',SPLITS => ['1000','2000','3000','4000']

# 生成16进制序列预分区
create 'staff2','info','partition2',{NUMREGIONS => 15, SPLITALGO => 'HexStringSplit'}

# 按照文件中设置的规则预分区
创建splits.txt文件内容如下：
aaaa
bbbb
cccc
dddd
然后执行：
create 'staff3','partition3',SPLITS_FILE => 'splits.txt'

# 使用JavaAPI创建预分区
  //自定义算法，产生一系列hash散列值存储在二维数组中
    byte[][] splitKeys = 某个散列值函数
  //创建HbaseAdmin实例
  HBaseAdmin hAdmin = new HBaseAdmin(HbaseConfiguration.create());
  //创建HTableDescriptor实例
  HTableDescriptor tableDesc = new HTableDescriptor(tableName);
  //通过HTableDescriptor实例和散列值二维数组创建带有预分区的Hbase表
  hAdmin.createTable(tableDesc, splitKeys);

11.3. HBase的RowKey设计（随机性，防止数据倾斜）

一条数据的唯一标识就是RowKey，那么这条数据存储于哪个分区，取决于RowKey处于哪个一个预分区的区间内，设计RowKey的主要目的，就是让数据均匀的分布于所有的region中，在一定程度上防止数据倾斜。接下来我们就谈一谈RowKey常用的设计方案。

# 生成随机数、hash、散列值
比如：
原本rowKey为1001的，SHA1后变成：dd01903921ea24941c26a48f2cec24e0bb0e8cc7
原本rowKey为3001的，SHA1后变成：49042c54de64a1e9bf0b33e00245660ef92dc7bd
原本rowKey为5001的，SHA1后变成：7b61dec07e02c188790670af43e717f0f46e8913
在做此操作之前，一般我们会选择从数据集中抽取样本，来决定什么样的rowKey来Hash后作为每个分区的临界值。

# 字符串反转
20170524000001转成10000042507102
20170524000002转成20000042507102
这样也可以在一定程度上散列逐步put进来的数据。

# 字符串拼接
20170524000001_a12e
20170524000001_93i7

11.4. HBase的内存优化

HBase操作过程中需要大量的内存开销，毕竟Table是可以缓存在内存中的，一般会分配整个可用内存的70%给HBase的Java堆。但是不建议分配非常大的堆内存，因为GC过程持续太久会导致RegionServer处于长期不可用状态，一般16~48G内存就可以了，如果因为框架占用内存过高导致系统内存不足，框架一样会被系统服务拖死。

11.5. HBase基础优化

1.允许在HDFS的文件中追加内容
hdfs-site.xml、hbase-site.xml
属性：dfs.support.append
解释：开启HDFS追加同步，可以优秀的配合HBase的数据同步和持久化。默认值为true。

2．优化DataNode允许的最大文件打开数
hdfs-site.xml
属性：dfs.datanode.max.transfer.threads
解释：HBase一般都会同一时间操作大量的文件，根据集群的数量和规模以及数据动作，设置为4096或者更高。默认值：4096

3．优化延迟高的数据操作的等待时间
hdfs-site.xml
属性：dfs.image.transfer.timeout
解释：如果对于某一次数据操作来讲，延迟非常高，socket需要等待更长的时间，建议把该值设置为更大的值（默认60000毫秒），以确保socket不会被timeout掉。

4．优化数据的写入效率
mapred-site.xml
属性：
mapreduce.map.output.compress
mapreduce.map.output.compress.codec
解释：开启这两个数据可以大大提高文件的写入效率，减少写入时间。第一个属性值修改为true，第二个属性值修改为：org.apache.hadoop.io.compress.GzipCodec或者其他压缩方式。

5．设置RPC监听数量
hbase-site.xml
属性：Hbase.regionserver.handler.count
解释：默认值为30，用于指定RPC监听的数量，可以根据客户端的请求数进行调整，读写请求较多时，增加此值。

6．优化HStore文件大小
hbase-site.xml
属性：hbase.hregion.max.filesize
解释：默认值10737418240（10GB），如果需要运行HBase的MR任务，可以减小此值，因为一个region对应一个map任务，如果单个region过大，会导致map任务执行时间过长。该值的意思就是，如果HFile的大小达到这个数值，则这个region会被切分为两个Hfile。

7．优化HBase客户端缓存
hbase-site.xml
属性：hbase.client.write.buffer
解释：用于指定Hbase客户端缓存，增大该值可以减少RPC调用次数，但是会消耗更多内存，反之则反之。一般我们需要设定一定的缓存大小，以达到减少RPC次数的目的。

8．指定scan.next扫描HBase所获取的行数
hbase-site.xml
属性：hbase.client.scanner.caching
解释：用于指定scan.next方法获取的默认行数，值越大，消耗内存越大。

9．flush、compact、split机制
当MemStore达到阈值，将Memstore中的数据Flush进Storefile；compact机制则是把flush出来的小文件合并成大的Storefile文件。split则是当Region达到阈值，会把过大的Region一分为二。
涉及属性：
即：128M就是Memstore的默认阈值
hbase.hregion.memstore.flush.size：134217728
即：这个参数的作用是当单个HRegion内所有的Memstore大小总和超过指定值时，flush该HRegion的所有memstore。RegionServer的flush是通过将请求添加一个队列，模拟生产消费模型来异步处理的。那这里就有一个问题，当队列来不及消费，产生大量积压请求时，可能会导致内存陡增，最坏的情况是触发OOM。
hbase.regionserver.global.memstore.upperLimit：0.4
hbase.regionserver.global.memstore.lowerLimit：0.38
即：当MemStore使用内存总量达到hbase.regionserver.global.memstore.upperLimit指定值时，将会有多个MemStores flush到文件中，MemStore flush 顺序是按照大小降序执行的，直到刷新到MemStore使用内存略小于lowerLimit

博文参考

https://www.cnblogs.com/datadance/p/16327298.html

https://www.cnblogs.com/datadance/p/16327298.html

庄小焱
关注
专栏目录
Hbase基础概念
m0_57697768的博客
07-25 1429
HBase组成架构，Master,RegionServer；HBase读写流程，HFile文件结构，布隆过滤器
1.HBase_工作原理
风不止步的博客
10-23 487
1.HBase介绍 HBase是一种Hadoop Database，是一个高可靠性、高性能、面向列、可伸缩、 实时读写的分布式数据库。利用Hadoop HDFS存储HBase的数据文件,利用Hadoop MapReduce来处理HBase中的海量数据,利用Zookeeper作为HBase分布式协同服务。主要用来存储非结构化和半结构化的松散数据。 2.HBase数据模型   RowKey ...
Hbase简介和快速入门
最新发布
m0_37689903的博客
07-28 1231
本文首先简单介绍了Hbase的定义，逻辑结构，物理存储结构；然后详细的介绍了Hbase的安装；最后简单介绍了Hbase的shell命令操作
HBase 原理
Gldwolf的博客
06-22 1153
1. HBase 底层原理 1.1 系统架构 1.1.1 Client 职责 1. HBase 有两张特殊的表： .META.: 记录了用户所有表拆分出来的 Region 映射信息，.META. 可以有多个 Region -ROOT-(新版中已去掉这一层): 记录了 .META. 表的 Region 信息，-ROOT- 只有一个 Region，无论如何都不会分裂 2. Client...
Hbase(五) hbase内部原理
weixin_30443895的博客
05-11 146
一、系统架构 客户端连接hbase依赖于zookeeper，hbase存储依赖于hadoop client： 1、包含访问 hbase 的接口， client 维护着一些 cache（缓存） 来加快对 hbase 的访问，比如 region 的位置信息。 （经常使用的表的位置信息） zookeeper： 1、保证任何时候，集群中只有一个 master2、存贮所有 ...
Hbase原理（底层原理，存储架构，寻址策略，读写流程，master和Regionserver的工作机制）
qichangjian的博客
03-05 1805
目录 1.hbase的底层逻辑架构 2.hbase的底层物理存储原理 3.hbase的寻址机制 4.hbase的读写过程 5.master和Regionserver的工作机制 1.hbase的底层逻辑架构 （1）新旧版本的hbase的架构区别 这是旧版本的hbase的架构图，一个regionserver中只有一个Hlog。 这一张是新版本的图，每一个regionserver中可以有30个Hlog...
1、Hbase原理详解
sinat_30802291的博客
06-26 1万+
1.Hadoop生态系统 Zookeeper分布式监控中心: HDFS的NameNode和MapReduce高可用。 zookeeper内部维护一个内存数据库。 存储Hbase一些数据（后续再谈） MapReduce:分布式计算框架 Hive:数据仓库 HBase:非关系型数据库 HDFS:分布式文件系统 F...
HBase 基本原理
06-14
HBase 基本原理，出版于 2014，HBase is a NoSQL database that primarily works on top of Hadoop. HBase is based on the storage architecture followed by the BigTable. HBase inherits the storage design from the column-oriented databases and the data access design from the keyvalue store databases where a key-based access to a specific cell of data is provided.
HBase基本原理
坐禅小和尚的专栏
10-18 6127
HBase以表的形式存储数据。与关系型数据库一样，在HBase中，表由行和列组成。与关系型数据库不同的是，HBase还有“列簇”（column family）的概念。一个表有若干“列簇”组成，每一个“列簇”包含若干列（column）。与此同时，表中的每一个cell都是有时间戳的。因此我们可以把其想象成一个三维数据库。除了行和列之外，还有一个时间维度，每一个单元格（cell）的不同版本都被保存。
HBase概述——HBase的存储模型.pdf
07-11
《HBase概述——HBase的存储模型》这篇文章深入解析了HBase的核心存储机制，即LSM树（Log-Structured Merge Tree）。LSM树是一种优化的存储结构，它旨在解决大数据场景下的高性能写入和读取需求。在HBase中，LSM树的...
大数据——分布式数据库HBase
liuYLyl的博客
06-16 831
第一节. 概述 第二节. HBase访问接口 第三节.HBase数据模型 第四节. HBase的实现原理 第五节.HBase运行机制 第六节.应用方案 第七节.HBase编程实践 一、概述 1.简介 HBase是谷歌BigTable的开源实现。 HBase是一个高可靠、高性能、面向列、可伸缩的分布式数据库。 HBase主要用来存储非结构化和半结构化的松散数据。 Hbase架构在HDFS之上，HDFS是存储完全非结构化数据 HBase的目标是处理非常庞大的表，可以通过水平扩展的方式，利用廉价计算机集群处理由超
HBase实战：大数据存储技术——学习HBase数据库的应用场景和使用技巧
程序员光剑
09-14 2173
Apache HBase是一个分布式、可扩展、高性能的NoSQL数据库。它是一个列族数据库，由Apache基金会所开发。它支持稀疏和密集存储，提供了一个高度可伸缩的系统，并能够在线地进行横向扩展。HBase提供了一个高效率的数据访问接口，可以使用SQL或Java API访问HBase数据库。HBase采用了Google的BigTable设计理念，将内存中的数据结构存放在硬盘上，通过压缩和批量加载方式来减少对磁盘的读写操作，提升查询效率。列族（Column Family）是一种组织数据的方式。
Hadoop详解(六)——HBASE原理、HBASE的集群安装、常用命令和Java接口
09-04 1416
HBASE简介HBASE是bigtable的开源山寨版本。是建立在HDFS基础之上，提供高可靠性、高性能、列存储、可伸缩、实时读写的数据库系统。它介于nosql和RDBMS之间，仅能通过主键(row key)和主键的range来检索数据，仅支持单行事务(可通过hive支持来实现多表join)等复杂操作。主要用来存储非结构化和半结构化的松散数据。与Hadoop一样，HBASE目标主要依靠横向扩展，通
大数据面试系列之——Hbase
风尘子曰
02-05 477
Hbase是一个分布式的列式存储的数据库 1.说说Hbase的特点 1.分布式架构，Hbase通过集群存储数据，数据最终会落到HDFS上 2.是一种NoSQL的非关系型数据库，不符合关系型数据库的范式 3.面向列存储，底层基于key-value结构 4.适合存储半结构化、非结构化的数据 5.适合存储稀疏的数据，空的数据不占用空间 6.提供实时的增删改查的能力，但是不提供严格的事务机制，只能在行级别...
hbase之原理详解
qq_38180223的博客
07-01 380
1、hbase的架构首先我们介绍hbase的架构如图所示，hbase的最底层结构是基于hdfs的，它将自己的日志文件`hlog`，以及数据表`Region`存储在hdfs的datanode当中。而管理hbase的主要是zookeeper和master。其中，hbase主要依靠zookeeper管理，master仅仅负责当启动hbase时，分配区域到指定区域服务器。当hbase启动以后master几...
Hbase基本原理剖析
热门推荐
hello.reader
07-21 2万+
每个Region包含了表中一段RowKey区间范围内的数据，HBase的一张数据表开始只包含一个Region，随着表中数据的增多，当一个Region的大小达到容量上限后会分裂成两个Region。为了提升数据操作的效率，HBase Client会在内存中缓存“hbase:meta”和用户表Region的信息，当应用程序发起下一次数据操作时，HBase Client会首先从内存中获取这些信息；上图 RegionServer的数据存储结构中Region的各部分的说明如表 Region结构说明所示。
HBase学习笔记（一）——HBase工作原理
u011047968的专栏
06-17 1460
类似 MySQL 或者 Oracle 关系型数据库，当用户表的数据达到几千万甚至几亿级别的时候，对单挑数据的检索将花费数秒甚至达到分钟级别。目前在海量数据下进行快速开发，并进行高效运行的需求越来越多，传统的关系型数据库似乎达到了瓶颈，怎么办？ 有的专家尝试将关系型数据库做成分布式数据库，把压力分摊到多个服务器上，但是，随之而来的问题则是很难保证原子性。原子性可是数据库最根本的 ACID 中的元素，如果没有了原子性，数据库就不可靠了。如果增加一些必要的操作，那么原子性是保证了，但是性能却大幅下降。专家们
Hbase 基本原理总结
嘻哈吼嘿呵的博客
08-04 686
一、HBase 基本框架 1、框架结构 HBase是一个构建在HDFS上的分布式列存储系统；HBase是Apache Hadoop生态系统中的重要一员，主要用于海量结构化数据存储；从逻辑上讲，HBase将数据按照表、行和列进行存储。与hadoop一样，Hbase目标主要依靠横向扩展，通过不断增加廉价的商用服务器，来增加计算和存储能力。 2、Hbase表的特点 （1）、大：一个表可以有数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

庄小焱

我将坚持分享更多知识

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值