利用Java的Stream API处理海量数据

前言

最近优化一个旧的HBase查询程序，在HBase查询出来的数据量太大的时候就会出现性能下降、内存溢出的问题。遂着手优化这个问题，将解决过程记录下来。

问题描述

一个旧的HBase查询程序，会从HBase数据库查询所需要的记录，将查询结果以JSON形式返回给客户端，整个程序基于Vertx之上构建。但是我们都知道HBase存储着海量的数据，当数据量太大的时候，这个程序就会出现响应速度慢，甚至内存溢出等现象。最近准备迁移旧的系统，于是着手修复这个问题。

问题分析

首先很容易想到的就是查询数据 --> 响应给客户端这部分可能出了问题，先看看这部分程序的代码(groovy)。大致如下(代码示例而已，非完整可执行代码):

List scanResult() {
    Scan scan = new Scan() // 其他查询条件忽略
    ResultScanner resultScanner = hTable.getScanner(scan)
    LinkedList list = new LinkedList()
    resultScanner.each { Result result ->
        List data = []
        result.rawCells().each {
            data << new JsonObject(Bytes.toString(CellUtil.cloneValue(it))
         }
         list.addFirst(data)
     }
     resultScanner.close()

     list
}

Closure responseToClinet(RoutingContext context) {
        { List result ->
            JsonObject data = new JsonObject()
            data.put('success', true)
            data.put('result', result)
            context.response().end(data.encodePrettily(), 'utf-8')
        }
}

将从HBase中查询的结果放入一个List中，再将这个json格式化之后响应给客户端。所以这个问题就很明显了，如果这个Scan的结果集特别大，将会造成整个List内存溢出，而且将List格式化成Json也需要消耗大量的时间，这就造成客户端请求的时候往往等上半天。

第一次优化

首先解决一下Json格式化的消耗问题，将一个超大的Map在内存中格式化成Json输出给客户端，这个操作本身就需要消耗大量的时间和内存，所以先从这里入手，规避在最后把一个超大的JsonObject对象格式化，而是在输出之前我就手工格式化成json字符串流的形式，不需要在输出的时候做。正好vertx在HttpServerResponse是支持io.vertx.core.buffer.Buffer的，那么我在格式化List这里的时候就手工拼接成一个String.join(",")的形式就好了

Buffer scanResult() {
    Scan scan = new Scan() // 其他查询条件忽略
    ResultScanner resultScanner = hTable.getScanner(scan)
    Buffer buffer = Buffer.buffer()
    resultScanner.each { Result result ->
        result.rawCells().each {
            String cellValue = Bytes.toString(CellUtil.cloneValue(it))
            if (buffer.length() > 0) {
                buffer.appendString(',' + cellValue)
            } else {
                buffer.appendString(cellValue)
            }
         }
     }
     resultScanner.close()

     buffer
}

Closure responseToClinet(RoutingContext context) {
        { Buffer result ->
            // 期望响应格式{"success":true,"result":[e1,e2,...,en]}
            HttpServerResponse response = context.response()
            response.setChunked(true)
            response.putHeader('Content-Type', 'application/json')
            response.write('{"success":true,"result":[')
            if (result) {
                response.write(result)
            }
            response.end(']}')
        }
}

很好，我们用手工拼接Buffer的形式，拼接出了一个超大的json字符串，这样节省了大量格式化json的时间。目前我们将一个原有5秒才能出结果的查询，降低到了0.5秒出结果，已经将速度大幅提升了。

但是这还不够，我们放开查询条件，进一步扩大Scan的结果集，依旧会出现内存溢出的错误。进一步审计代码和堆栈，发现这里出了问题:

    Buffer buffer = Buffer.buffer()
    resultScanner.each { Result result ->
        result.rawCells().each {
            String cellValue = Bytes.toString(CellUtil.cloneValue(it))
            if (buffer.length() > 0) {
                buffer.appendString(',' + cellValue)
            } else {
                buffer.appendString(cellValue)
            }
         }
     }

我们在循环中不断追加buffer，但是结果集超大，超出我们的预期的时候，buffer还是会把内存撑爆。看来我们还是得找更好的方案。

第二次优化

进一步审计ResultScanner的代码，发现它是这么定义的:

/**
 * Interface for client-side scanning.
 * Go to {@link Table} to obtain instances.
 */
@InterfaceAudience.Public
@InterfaceStability.Stable
public interface ResultScanner extends Closeable, Iterable

ResultScanner是一个Iterable对象。那我们可以这么考虑，能不能不要在迭代中一直拼接Buffer，而是迭代中每格式化一个Buffer之后，就把Buffer写入响应流中呢？这样不就解决了拼接buffer造成内存溢出的问题了吗？而且可以让响应时间进一步缩短。

这里就是Java 8新引入的java.util.Stream API了，不同于nio的Stream，这里的Stream是为了实现流式处理的接口，而且可以和java 8新加入的Lambda表达式进行更加灵活的处理。Stream就像水流一样，处理完就丢掉了，不会向前遍历，可以很方便的构造数据处理管道，正好符合我们的这个场景。一个Stream的典型处理场景如下:

image

而Iterable对象是非常容易转成Stream的，在java 8就提供了一个工具类java.util.stream.StreamSupport，可以很方便的把Iterable对象转成Stream。于是我们的代码改造如下:

Itertor scanResult() {
    Scan scan = new Scan() // 其他查询条件忽略
    resultScanner = hTable.getScanner(scan)
    boolean first = true
    StreamSupport.stream(resultScanner.spliterator(), false).map({ Result result ->
        Buffer buffer = Buffer.buffer()
        result.rawCells().each {
            String cellValue = Bytes.toString(CellUtil.cloneValue(it))
            if (first) {
                buffer.appendString(cellValue)
            } else {
                buffer.appendString(',' + cellValue)
            }
            first = false
        }
        buffer
    }).iterator()
}

Closure responseToClinet(RoutingContext context) {
    { Iterator bufferIterator ->
        // 期望响应格式{"success":true,"result":[e1,e2,...,en]}
        HttpServerResponse response = context.response()
        response.setChunked(true)
        response.putHeader('Content-Type', 'application/json')
        response.write('{"success":true,"result":[')
        bufferIterator?.each {
            response.write(it)
        }
        response.end(']}')
    }
}

// 调用部分示例，需要在迭代完成close掉ResultScanner
{ Iterator bufferIterator ->
    resultScanner?.withCloseable {
        responseToClinet(context).call(bufferIterator)
    }
}

至此，所有问题都得到了解决，查询再大的数据量也不会造成内存溢出了。

小结

本章我们通过一个实际的项目案例分析，展示了大数据处理的思想，以及使用Java 8新增的Stream API解决我们实际的问题。