HBase客户端实现并行扫描

最新推荐文章于 2022-06-09 11:39:50 发布
最新推荐文章于 2022-06-09 11:39:50 发布
阅读量350 收藏 1
点赞数
文章标签： 大数据 java shell
原文链接：https://yq.aliyun.com/articles/25777
版权

HBase中有一个类可以实现客户端扫描数据，叫做ClientScanner，该类不是并行的，有没有办法实现一个并行的扫描类，加快扫描速度呢？

如果是一个Scan，我们可以根据startkey和stopkey将其拆分为多个子Scan，然后让这些Scan并行的去查询数据，然后分别返回执行结果。

实现方式

说明：我使用的HBase版本为：cdh4-0.94.15_4.7.0。

在org.apache.hadoop.hbase.client创建ParallelClientScanner类，代码如下：

package org.apache.hadoop.hbase.client;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HConstants;
import org.apache.hadoop.hbase.Stoppable;
import org.apache.hadoop.hbase.util.Bytes;

public class ParallelClientScanner extends AbstractClientScanner {
  private static final int SCANNER_WAIT_TIME = 1000;
  private final HTableInterface table;
  private final int resultQueueSize;
  private final int threadCount;
  private List<Scan> scans;
  private Iterator<Scan> iter;
  private ParallelScannerWorkerThread currThread;
  private Queue<ParallelScannerWorkerThread> nextThreads;
  private boolean closed;

  public ParallelClientScanner(Configuration conf, Scan scan,
      byte[] tableName, List<byte[]> splitKeys) throws IOException {
    this(new HTable(conf, tableName), scan, splitKeys);
  }

  public ParallelClientScanner(HTableInterface table, Scan scan,
      List<byte[]> splitKeys) throws IOException {
    this.table = table;
    this.resultQueueSize = table.getConfiguration().getInt(
      "hbase.parallel.scanner.queue.size", 1000);

    this.threadCount = (table.getConfiguration().getInt(
      "hbase.parallel.scanner.thread.count", 10) - 1);

    this.scans = new ArrayList<Scan>();
    byte[] stopRow = scan.getStopRow();
    byte[] lastSplitKey = scan.getStartRow();
    Scan subScan = null;
    for (Iterator<byte[]> it = splitKeys.iterator(); it.hasNext();) {
      byte[] splitKey = (byte[]) it.next();
      if ((Bytes.compareTo(splitKey, lastSplitKey) <= 0)
          || ((Bytes.compareTo(splitKey, stopRow) >= 0) && (!Bytes
              .equals(stopRow, HConstants.EMPTY_END_ROW)))
          || (Bytes.equals(splitKey, HConstants.EMPTY_END_ROW))) {
        continue;
      }

      subScan = new Scan(scan);
      subScan.setStartRow(lastSplitKey);
      subScan.setStopRow(splitKey);
      subScan.setParallel(false);
      this.scans.add(subScan);
      lastSplitKey = splitKey;
    }
    subScan = new Scan(scan);
    subScan.setStartRow(lastSplitKey);
    subScan.setParallel(false);
    this.scans.add(subScan);

    this.nextThreads = new LinkedList<ParallelScannerWorkerThread>();
    this.closed = true;
    initialize();
  }

  public ParallelClientScanner(Configuration conf, List<Scan> scans,
      byte[] tableName) throws IOException {
    this(new HTable(conf, tableName), scans);
  }

  public ParallelClientScanner(HTableInterface table, List<Scan> scanList)
      throws IOException {
    if (null == scanList) {
      throw new IOException("ScanList cannot be null");
    }
    sort(scanList);

    this.table = table;
    this.resultQueueSize = table.getConfiguration().getInt(
      "hbase.parallel.scanner.queue.size", 1000);

    this.threadCount = (table.getConfiguration().getInt(
      "hbase.parallel.scanner.thread.count", 10) - 1);

    this.scans = new ArrayList<Scan>();
    Scan subScan = null;
    for (int i = 0; i < scanList.size(); i++) {
      subScan = new Scan((Scan) scanList.get(i));
      subScan.setParallel(false);
      this.scans.add(subScan);
    }

    this.nextThreads = new LinkedList<ParallelScannerWorkerThread>();
    this.closed = true;
    initialize();
  }

  protected void initialize() throws IOException {
    try {
      this.iter = this.scans.iterator();
      if (this.iter.hasNext()) {
        this.currThread = new ParallelScannerWorkerThread(
            (Scan) this.iter.next());
        this.currThread.start();
      }
      while ((this.iter.hasNext())
          && (this.nextThreads.size() < this.threadCount)) {
        ParallelScannerWorkerThread worker = new ParallelScannerWorkerThread(
            (Scan) this.iter.next());

        this.nextThreads.offer(worker);
        worker.start();
      }
      this.closed = false;
    } catch (IOException e) {
      close();
      throw e;
    }
  }

  public void close() {
    this.closed = true;
    if (this.currThread != null) {
      this.currThread.stop("Closed by user.");
    }
    for (ParallelScannerWorkerThread worker : this.nextThreads)
      worker.stop("Closed by user.");
  }

  public Result next() throws IOException {
    try {
      return nextInternal();
    } catch (IOException e) {
      close();
      throw e;
    }
  }

  private Result nextInternal() throws IOException {
    if ((this.closed) || (this.currThread == null)) {
      return null;
    }

    Result next = this.currThread.next();
    if (next != null) {
      return next;
    }

    if (this.currThread.isError()) {
      Exception ex = this.currThread.getException();
      throw ((ex instanceof IOException) ? (IOException) ex
          : new IOException(ex));
    }

    while ((next == null) && (this.currThread != null)) {
      if (!this.currThread.isStopped()) {
        this.currThread.stop("Scanner complete.");
      }
      this.currThread = ((ParallelScannerWorkerThread) this.nextThreads
          .poll());
      if (this.iter.hasNext()) {
        ParallelScannerWorkerThread worker = new ParallelScannerWorkerThread(
            (Scan) this.iter.next());

        this.nextThreads.offer(worker);
        worker.start();
      }
      if (this.currThread != null) {
        next = this.currThread.next();
      }
    }

    return next;
  }

  public Result[] next(int nbRows) throws IOException {
    ArrayList<Result> resultSets = new ArrayList<Result>(nbRows);
    for (int i = 0; i < nbRows; i++) {
      Result next = next();
      if (next == null) break;
      resultSets.add(next);
    }

    return (Result[]) resultSets.toArray(new Result[resultSets.size()]);
  }

  private void sort(List<Scan> scanList) throws IOException {
    Collections.sort(scanList, new ScanComparator());
    for (int i = 1; i < scanList.size(); i++) {
      byte[] currentStartRow = ((Scan) scanList.get(i)).getStartRow();
      byte[] lastStopRow = ((Scan) scanList.get(i - 1)).getStopRow();

      if ((lastStopRow == null) || (lastStopRow.length == 0)) throw new IOException(
          "Scan has overlap, last scan's stopRow is null");
      if ((currentStartRow == null) || (currentStartRow.length == 0)) {
        throw new IOException(
            "Scan has overlap, current scan's startRow is null");
      }
      if (0 >= Bytes.compareTo(lastStopRow, 0, lastStopRow.length,
        currentStartRow, 0, currentStartRow.length)) continue;
      throw new IOException(
          "Scan has overlap, current scan's startRow is smaller than last scan's stop row");
    }
  }

  private static class ScanComparator implements Comparator<Scan> {
    public int compare(Scan o1, Scan o2) {
      if ((o1.getStartRow() == null) || (o1.getStartRow().length == 0)) return -1;
      if ((o2.getStartRow() == null) || (o2.getStartRow().length == 0)) {
        return 1;
      }
      byte[] o1StartRow = o1.getStartRow();
      byte[] o2StartRow = o2.getStartRow();
      return Bytes.compareTo(o1StartRow, 0, o1StartRow.length,
        o2StartRow, 0, o2StartRow.length);
    }
  }

  private class ParallelScannerWorkerThread extends Thread implements
      Stoppable {
    private ResultScanner scanner;
    private BlockingQueue<Result> results;
    private Object empty;
    private AtomicBoolean stopped;
    private Exception exception;

    protected ParallelScannerWorkerThread(Scan scan) throws IOException {
      this.scanner = ParallelClientScanner.this.table.getScanner(scan);
      this.results = new ArrayBlockingQueue<Result>(
          ParallelClientScanner.this.resultQueueSize);
      this.empty = new Object();
      this.stopped = new AtomicBoolean(false);
    }

    public Result next() throws IOException {
      Result r = (Result) this.results.poll();
      while ((!this.stopped.get()) && (r == null)) {
        try {
          synchronized (this.empty) {
            this.empty.wait();
          }
          r = (Result) this.results.poll();
        } catch (InterruptedException e) {
          throw ((IOException) (IOException) new IOException()
              .initCause(e));
        }
      }

      return r;
    }

    public void stop(String why) {
      this.stopped.compareAndSet(false, true);
    }

    public boolean isStopped() {
      return this.stopped.get();
    }

    public boolean isError() {
      return this.exception != null;
    }

    public Exception getException() {
      return this.exception;
    }

    public void run() {
      try {
        Result r = this.scanner.next();
        while (r != null) {
          boolean added = false;
          while (!added) {
            added = this.results.offer(r, SCANNER_WAIT_TIME,
              TimeUnit.MILLISECONDS);
          }
          synchronized (this.empty) {
            this.empty.notify();
          }
          r = this.scanner.next();
        }
      } catch (IOException ioe) {
        this.exception = ioe;
      } catch (InterruptedException ite) {
        this.exception = ite;
      } finally {
        this.scanner.close();
        this.stopped.compareAndSet(false, true);
        synchronized (this.empty) {
          this.empty.notify();
        }
      }
    }
  }
}

然后，需要对Scan做些修改：

  • 作为一个新特性，你需要修改SCAN_VERSION值
  • 增加parallel属性，用于判断是否需要并行扫描
  • 你需要修改序列化和反序列化方法，加上parallel的值
  • 修改HTable中原来的public ResultScanner getScanner(final Scan scan)方法

修改SCAN_VERSION版本值为3，原来值为2：

private static final byte SCAN_VERSION = (byte)3;

在合适地方添加一个parallel属性和get/set方法：

this.parallel = scan.isParallel();

private boolean isParallel() {
	return parallel;
}

public void setParallel(boolean parallel) {
	this.parallel = parallel;
}

在public Scan(Scan scan)构造方法中初始化parallel属性：

public Scan(Scan scan) throws IOException {
    startRow = scan.getStartRow();
    stopRow  = scan.getStopRow();
    maxVersions = scan.getMaxVersions();
    batch = scan.getBatch();
    caching = scan.getCaching();
    cacheBlocks = scan.getCacheBlocks();
    filter = scan.getFilter(); // clone?
    this.parallel = scan.isParallel(); 		// 初始化parallel属性
    TimeRange ctr = scan.getTimeRange();
    tr = new TimeRange(ctr.getMin(), ctr.getMax());
    Map<byte[], NavigableSet<byte[]>> fams = scan.getFamilyMap();
    for (Map.Entry<byte[],NavigableSet<byte[]>> entry : fams.entrySet()) {
      byte [] fam = entry.getKey();
      NavigableSet<byte[]> cols = entry.getValue();
      if (cols != null && cols.size() > 0) {
        for (byte[] col : cols) {
          addColumn(fam, col);
        }
      } else {
        addFamily(fam);
      }
    }
    for (Map.Entry<String, byte[]> attr : scan.getAttributesMap().entrySet()) {
      setAttribute(attr.getKey(), attr.getValue());
    }
  }

在public Map<String, Object> toMap(int maxCols)中添加上parallel属性：

map.put("parallel", Boolean.valueOf(this.parallel));

修改readFields方法，在最后添加代码：

if (version > 2) {
    this.parallel = in.readBoolean();
}

修改write方法，在最后添加代码：

out.writeBoolean(this.parallel);

修改HTable中原来的public ResultScanner getScanner(final Scan scan)方法如下：

public ResultScanner getScanner(final Scan scan) throws IOException {
	if (scan.getCaching() <= 0) {
		scan.setCaching(getScannerCaching());
	}
	return scan.getParallel() ? new ParallelClientScanner(this, scan, getStartKeysInRange(scan.getStartRow(), scan.getStopRow())) : new ClientScanner(getConfiguration(), scan, getTableName(), this.connection);
}

最后，如果你想再HBase shell中使用该特性，你要做如下修改：

修改src/main/ruby/hbase.rb，在SELECT = "SELECT"下面添加代码一行代码：

COLUMN_INTERPRETER="COLUMN_INTERPRETER"
KEY = "KEY"
SELECT = "SELECT"
PARALLEL = "PARALLEL"

修改src/main/ruby/hbase/table.rb，在raw = args["RAW"] || false下面添加一行代码：

parallel = args["PARALLEL"] || false

在scan.setRaw(raw)下面添加一行代码：

scan.setMaxVersions(versions) if versions > 1
scan.setTimeRange(timerange[0], timerange[1]) if timerange
scan.setRaw(raw)
scan.setParallel(parallel)

修改完之后，编译源代码，就可以进行测试了。

测试

  1. 通过hbase shell测试

运行hbase shell进行测试：

hbase(main):003:0> scan 't',{PARALLEL=>true}
ROW                                      COLUMN+CELL                                                                                                        
 1                                       column=f:id, timestamp=1382528597662, value=1
 2                                       column=f:id, timestamp=1382528594343, value=2
 3                                       column=f:id, timestamp=1382528478893, value=3
 4                                       column=f:id, timestamp=1382528483161, value=4
4 row(s) in 0.0240 seconds
  1. 通过hbase client测试

创建ParallelScannerTest.java类并添加如下代码：

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.client.HTable;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.ResultScanner;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.filter.SingleColumnValueFilter;
import org.apache.hadoop.hbase.util.Bytes;

public class ParallelScannerTest {
  public static void main(String[] args) throws Exception {
    Configuration conf = HBaseConfiguration.create();
    HTable table = new HTable(conf, "t");
    String startKey = "1";
    String stopKey = "3";
    Scan scan = new Scan(Bytes.toBytes(startKey), Bytes.toBytes(stopKey));
    int count = 0;
    
    scan.setParallel(true);

    ResultScanner scanner = table.getScanner(scan);
    Result r = scanner.next();
    while (r != null) {
      count++;
      r = scanner.next();
    }
    System.out.println("++ Scanning finished with count : " + count + " ++");
    scanner.close();
    table.close();
  }
}

运行该类并查看输出结果。

你可以在hbase-site.xml中修改线程数大小和队列大小，下面两个参数：

  • hbase.parallel.scanner.queue.size
  • hbase.parallel.scanner.thread.count

以上源代码及所做的修改我已提交到我github仓库上hbase的cdh4-0.94.15_4.7.0分支，见提交日志add ParallelClientScanner。

weixin_34242509
关注
hbase学习笔记.doc
05-09
HBase构建于Apache Hadoop之上，利用HDFS作为其底层存储系统，并且与MapReduce框架集成，支持大规模并行计算。 在HBase中，数据被组织成表格形式，但不同于传统的关系型数据库，HBase是面向列族的，这意味着每个表...
二十、HBase扫描
Fabio的博客
07-25 309
scan 命令用于查看HTable数据。使用 scan 命令可以得到表中的数据。它的语法如下： scan ‘&lt;table name&gt;’ 下面的示例演示了如何使用scan命令从表中读取数据。在这里读取的是emp表。 hbase(main):010:0&gt; scan 'emp' ROW COLUMN+CELL 1 co...
hbase的调优
Allenzyg的博客
06-09 1079
默认情况下，在创建HBase表的时候会自动创建一个region分区，当导入数据的时候，所有的HBase客户端都向这一个region写数据，直到这个region足够大了才进行切分。一种可以加快批量写入速度的方法是通过预先创建一些空的regions，这样当数据写入HBase时，会按照region分区情况，在集群内做数据的负载均衡。 1.2 Row Key HBase中row key用来检索表中的记录，支持以下三种方式：在HBase中，row key可以是任意字符串，最大长度64KB，实际应......
HBase优化
TU_JCN的博客
08-17 873
一、IOT表的优化 1、IOT表现状 IOT数据采集表 采集IOT设备每秒钟数据，存入hbase，rowkey为时间戳+设备名，按时间进行预分区； 其中，一张IOT表里，有10个设备每秒钟采集6个自己区域的监测值，一天的数据为10*(60*60*24) = 844000条数据 列为：每个设备的监测区域ID（如AacW6cTXG20、AacW6cTXG21、AacW6cTXG23…）+ 设备ID，一共10*6+1=61列。 如果，要通过Pheonix查询，需要在pheonix中建立相应映射
HBase Scan命令详解
zy353003874的博客
09-16 1万+
hbase中scan命令是我们经常使用到的，而filter的作用尤其强大。这里简要的介绍下scan下filter命令的使用. 插入scan命令需要的数据 这里模拟了部分微博评论的数据,然后使用代码插入数据到hbase,代码就不列出来了比较简单。 public class Comment { //1-->普通文章，2--->热点文章 Integer articleType; //文章id String articleId; String userId;
hbase并行scan
大神带我来搬砖
01-15 1065
hbase自带的scan是串行的,在一个region扫描完了以后,会通过nextScanner方法扫描下一个region. 有没有办法并行的扫描多个region呢?设想了一下,可以利用getRegionLocations得到一个HTable的region info的集合,这样就可以知道每个region的startrow和endrow,根据要扫描的条件,构造多个scan,使每个scan都分别设定对...
Interactive SQL query on HBase (孙元浩)
05-08
《交互式SQL查询在HBase上》这篇文章由孙元浩撰写，主要探讨了为什么需要在HBase上实现交互式查询，以及如何通过架构和HBase SQL操作符来实现这一需求。文章详细介绍了HBase SQL的功能特点和性能。 在介绍为什么...
hadoop2.73-eclipse开发hbase所需要的所有jar包
09-11
正确配置后，可以使用HBase的API创建表、插入数据、执行扫描和查询等操作。 在实际开发过程中，除了基本的JAR依赖，可能还需要根据具体需求添加其他库，例如Hadoop的Avro或Parquet模块，用于数据序列化和存储。同时...
Hbase coprecessor
11-15
用户可以通过高阶调用接口与 Coprocessor 交互，这些调用可以针对单行或多行数据，并通过客户端库进行映射和并行化处理。这样不仅实现了请求自动路由，还确保了应用逻辑与数据同步扩展。 #### HBase Coprocessor 的...
[原创]HbaseClient
03-20
3. 并行处理：HbaseClient支持多线程并行操作，可以提高数据处理效率。例如，`Table`对象的`batch`方法可以同时执行多个操作。 4. 错误处理：HbaseClient具有良好的错误恢复机制，当服务器端出现问题时，客户端会...
hbase操作详情
小五的世界
06-15 395
1、启动hbase客户端 ./bin/hbase shell 2、查看当前状态 status 3、建表和列族 create ‘tbx1’,‘cf1’ create ‘tabx4’, {NAME => ‘cf1’, VERSIONS => 3} 4、查看列表： list 5、查看结构 describe ‘tabx4’ 或desc ‘tabx4’ 6、put添加 Put命令参数说明：表名，键值，列族，列明，值 put ‘tabx4’,‘rk1’,‘cf1:c1’,‘v11
Hbase Scanner 排序标准
Terry Zhang Data Solution
12-08 4229
KeyValueHeap 中定义对 KVScannerComparator 比较标准顺序如下： 1. 根据TOP rowkey 排序。 RowKey 排序如下      a).  row Key的byte值 正向排序      b). row type 是否是Minimum. 谁是Min 谁值最大（左值优先），排在队列后面      c). column 和 Qualifier 正
HBase高性能复杂条件查询引擎
热门推荐
Laurence的技术博客
06-17 4万+
版权声明：本文由本人撰写并发表于2014年7月份的InfoQ，HBase的PMC成员Ted Yu先生参与了审稿并于给予了肯定。该方案设计之初仅寄希望于通过二级索引提升查询性能，由于在前期架构时充分考虑了通用性以及对复杂条件的支持，在后来的演变中逐渐被剥离出来形成了一个通用的查询引擎。HBase在大数据领域的应用越来越广泛，成为目前NoSQL数据库中表现最耀眼，呼声最高的产品之一，但就应对复杂条件的查询来说，一般认为它并不是非常适合，熟悉HBase的开发人员对此应该有一定的体会，但是基于普遍的需求，开发者们希
为何HBase速度很快
我喂自己袋盐
03-17 1万+
为何HBase速度很快
Elasticsearch+Hbase实现海量数据秒回查询
静待花开
01-03 1万+
文章出处：http://blog.csdn.net/sdksdk0/article/details/53966430 作者：朱培      ID：sdksdk0      -------------------------------------------------------------------------------------------- 首先祝大家2017新年快乐，
hbase scan超时设置_深入浅出HBase系列（二）
weixin_39940788的博客
12-01 249
今天来讲讲HBase读的过程:1、HBase读过程详解2.1影响HBase读取命令的参数HBase读包含两种命令:get ，基于确切的RowKey去获取一行数据，通常被称之为随机点查；scan，指定一个RowKey的范围区间，获取该区间的所有记录，当区间未明确指定时，scan退化为全表扫描；图2.1 client端scan的示意图Client每一次往RegionServer发送scan请求，都会批...
关于hbase中scan的一些总结
lvwenyuan_1的博客
11-02 1万+
首先，对于scan来说，哪些会全表扫描，哪些不会全表扫描。 对于这点，笔者原来有些疑惑，以为只要是对于scan来说，都会全表扫描。最近阅读了一些源码以及和咨询一些大神，稍微总结了下。                 什么是scan，scan是较为底层的也是用的最多的一种获取Hbase中数据的方式，在它的上面还封装了几种基于scan的获取方式的数据，例如snapshotScanMR,TableS
mr任务之从多个Hbase表中读取数据进行处理
maixia24的专栏
08-05 5197
从两个不同的Hbase表中读取数据：
HBase的交互式SQL查询：性能与实现架构
为了实现高效并行扫描和过滤多个区域，HBase引入了并行扫描器（pscan），可以在不同的服务器上同时处理多个区域。同时，与Hive这样的工具集成也是解决方案的一部分，它提供了类似SQL的接口，虽然可能在执行某些复杂...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值