我的代码算法如下
第一步。获取一个hbase实体数据到hBaseRDD

      JavaPairRDD<ImmutableBytesWritable, Result> hBaseRDD = 
                 jsc.newAPIHadoopRDD(hbase_conf,  TableInputFormat.class,
                 ImmutableBytesWritable.class, Result.class); 

第二步。将 hBaseRDD 转换为 rowPairRDD

     // in the rowPairRDD the key is hbase's row key, The Row is the hbase's Row data 
     JavaPairRDD<String, Row> rowPairRDD = hBaseRDD 
                            .mapToPair(***); 
    dataRDD.repartition(500);
        dataRDD.cache();

第 3 步。将 rowPairRDD 转换为 schemaRDD

            JavaSchemaRDD schemaRDD =   sqlContext.applySchema(rowPairRDD.values(), schema); 
            schemaRDD.registerTempTable("testentity"); 
           sqlContext.sqlContext().cacheTable("testentity");

第四步。使用 spark sql 做第一个简单的 sql 查询。

   JavaSQLContext  sqlContext = new org.apache.spark.sql.api.java.JavaSQLContext(jsc);
    JavaSchemaRDD retRDD=sqlContext.sql("SELECT column1, column2 FROM testentity WHERE 
             column3 = 'value1' ") 
     List<org.apache.spark.sql.api.java.Row> rows = retRDD.collect(); 

第 5 步。使用 spark sql 做第二个简单的 sql 查询。

JavaSchemaRDD retRDD=sqlContext.sql("SELECT column1, column2 FROM testentity 
                                     WHERE column3 = 'value2' ") 
List<org.apache.spark.sql.api.java.Row> rows = retRDD.collect(); 

Step6. 使用spark sql做第三个简单的sql查询。

JavaSchemaRDD retRDD=sqlContext.sql("SELECT column1, column2 FROM testentity WHERE column3 = 'value3' "); 
List<org.apache.spark.sql.api.java.Row> rows = retRDD.collect(); 

测试结果如下:

测试用例1:

当我插入 300,000 条记录时，hbase 实体，然后运行代码。

• 第一个查询需要 60407 毫秒
• 第二个查询需要 838 毫秒
• 第 3td 查询需要 792 毫秒

如果我使用 hbase Api 做类似的查询，只需要 2000 毫秒。显然最后 2 个 spark sql 查询比 hbase api 查询快得多。
我相信第一个 spark sql 查询会花费大量时间从 hbase 加载数据。
所以第一个查询比最后两个查询慢得多。我觉得这个结果是意料之中的

测试用例2:

当我插入 400,000 条记录时。 hbase 实体，然后运行代码。

• 第一个查询需要 87213 毫秒
• 第二个查询需要 83238 毫秒
• 第 3td 查询需要 82092 毫秒

如果我使用 hbase Api 做类似的查询，只需要 3500 毫秒。显然 3 个 spark sql 查询比 hbase api 查询慢得多。
而且最后 2 个 spark sql 查询也很慢，性能与第一个查询相似，为什么？如何调整性能？

最佳答案

我怀疑您正在尝试缓存比分配给 Spark 实例更多的数据。我将尝试分解每次执行完全相同的查询时发生的情况。

首先，Spark 中的一切都是惰性的。这意味着当您调用 rdd.cache() 时，实际上什么都不会发生，直到您对 RDD 进行操作。

第一次查询

1. 完整的 HBase 扫描(慢速)
2. 增加分区数(导致shuffle，变慢)
3. 数据实际上缓存到内存中，因为 Spark 是惰性的(有点慢)
4. 应用 where 谓词(快速)
5. 收集结果

第二次/第三次查询

1. 全内存扫描(快速)
2. 应用 where 谓词(快速)
3. 收集结果

现在，Spark 将尝试缓存尽可能多的 RDD。如果它不能缓存整个东西，你可能会遇到一些严重的减速。如果 before 缓存步骤之一导致随机播放，则尤其如此。您可能会在第一个查询中为每个后续查询重复步骤 1 - 3。这并不理想。

要查看您是否没有完全缓存 RDD，请转到您的 Spark Web UI(http://localhost:4040 如果在本地独立模式下)并查找 RDD 存储/持久性信息.确保它是 100%。

编辑(根据评论):

400,000 data size in my hbase only about 250MB. Why I need to use 2G to fixed the issue(but 1G>>250MB)

我不能确定为什么您使用 spark.executor.memory=1G 达到最大限制，但我会添加一些有关缓存的更多相关信息。

• Spark 只分配一定百分比的执行程序堆内存用于缓存。默认情况下，这是 spark.storage.memoryFraction=0.6或 60%。所以你实际上只得到 1GB * 0.6。
• 在 HBase 中使用的总空间可能不同于在 Spark 中缓存时占用的总堆空间。默认情况下，Spark 在内存中存储时不会序列化 Java 对象。因此，在存储 Java Object 元数据时会产生相当大的开销。你可以change the default persistence level .

Do you know how to cache all the data to avoid the bad performance for the first query?

调用任何操作都会导致 RDD 被缓存。就这样做吧

scala> rdd.cache
scala> rdd.count

现在它被缓存了。

关于java - Spark SQL 性能，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27646171/