java-jar jvm

自然界的基本规则（例如光速和通用信息论）对我们可以从传统系统体系结构中获得的最大性能设置了明显的限制。

了解您作为Java开发人员如何使用JVM技术和Java流将性能提高几个数量级。

例如，如果应用程序服务器和数据库服务器相距100 m（约330英尺），则光速带来的往返延迟将略微超过600 ns。 更重要的是，由于采用了TCP / IP协议，尽管采用了黑带技巧（例如自定义内核），但10 GBit / s连接上的单个数据包往返延迟几乎无法优化到小于25 us（= 25,000 ns）。构建，繁忙的轮询和CPU关联性。

在本文中，我将展示如何使用JVM内存技术直接从RAM创建Java Streams。 我们将使用名为Speedment的基于Stream的Java ORM，它可以使用标准格式执行数据分析
java.util.stream.Stream对象以及如何在200 ns内创建和完成其中一些流的方法，令人惊讶的是，这仅是访问64位主内存的CPU延迟的两倍。

200 ns比其内部处理延迟为零且单个TCP数据包可以传达查询和响应的远程数据库（100 m）的理论最小延迟快125倍以上。 在实时方案中，数据库的内部处理延迟永远不会为零，并且查询和结果通常都以多个TCP包发送。 因此，在许多情况下，加速因子可能是1000倍甚至更多。

数据库

在下面的示例中，我们将Sakila数据库内容中的数据用于MySQL。 Sakila是为电影租赁商店建模的示例数据库。 它具有名为Film，Actor，Category等的表格，可以在此处免费下载。 应该注意的是，这是一个小型数据库，但事实证明，许多Speedment流操作的复杂度为O(1)或O(log(N()) ，因此无论大小有多大，都可以确保相同的速度或较小的数据集。

步骤1：建立专案

首先，我们需要配置我们pom.xml -file使用最新Speedment依赖和Maven插件。 最快的方法是生成一个
使用可以在此处找到的Speedment Initializer的pom.xml -file。 首先，选择数据库类型“ MySQL”，并确保启用“内存中加速”，然后按“下载”，您将获得一个完整的项目文件夹，其中包含为您自动生成的Main.java文件。

接下来，解压缩项目文件夹的zip文件，打开命令行，转到解压缩的文件夹（ pom.xml文件所在的文件夹），然后输入以下命令：

mvn speedment:tool

接下来，连接到数据库并开始：

步骤2：产生程式码

从数据库中加载模式数据后，可以通过按“生成”按钮来生成完整的Java域模型。

步骤3：编写应用程序代码

为了使用Speedment，首先需要创建一个Speedment实例。 这可以通过使用在步骤2中与域模型一起自动生成的构建器来完成。
Main.java文件并替换其中的代码
此代码段的main()方法：

Speedment app = new SakilaApplicationBuilder()// Replace this with your own password.withPassword("sakila-password")// Enable in-JVM-memory acceleration// By just commenting away this line, we can disable acceleration.withBundle(InMemoryBundle.class).build();// Load data from database into a snapshot view if// we have installed In-JVM-Accelerationapp.get(DataStoreComponent.class).ifPresent(DataStoreComponent::load);

作为基本功能的演示，我们将首先编写一个仅打印所有电影的应用程序：

// Obtains a FilmManager that allows us to
// work with the "film" table
FilmManager films = app.getOrThrow(FilmManager.class);// Create a stream of films and print
// each and every film
films.stream().forEach(System.out::println);

上面的代码将产生以下输出（为简便起见，以下简称）：

FilmImpl { filmId = 1, title = ACADEMY DINOSAUR, …, length = 86, ... }
FilmImpl { filmId = 2, title = ACE GOLDFINGER, ..., length = 48, ...}
FilmImpl { filmId = 3, title = ADAPTATION HOLES, ..., length = 50, ...}
...

步骤3：使用筛选器

Speedstream流支持所有流操作，包括过滤器。 假设我们只想过滤那些长于60分钟的影片，并计算发生的次数。 可以这样完成：

films.stream().filter(Film.LENGTH.greaterThan(60)).count();System.out.format("There are %,d films longer than 60 minutes.", count);

这将产生以下输出：

There are 896 films longer than 60 minutes

可以将任意数量的过滤器应用于流，并将谓词提供给
filter()方法可以使用
and() / or()运算符。

步骤4：设定JMH

到目前为止，我们还没有看到任何性能数据。 在本文中，我们将使用JMH进行基准测试。 JMH是一种Java工具，用于构建，运行和分析以Java和其他针对JVM的其他语言编写的基准。

我们将使用两种流类型来进行性能评估：

1. 这是一个相当简单的流程，我们在该流程中对评级等于PG-13的电影进行计数，称为“滤镜和计数”
2. 在更复杂的流中，我们按照LENGTH顺序对所有电影进行排序（降序），然后跳过前745部电影，然后处理以下5部电影，从而从这5部电影中提取租借时间，最后计算出这些整数的统计值（即最小值，最大值和平均值）。 这种类型称为“复杂”。

以下代码摘录显示了我们将要运行的基准测试：

private static final Predicate RATING_EQUALS_PG_13 = Film.RATING.equal(Rating.PG13);private static final Comparator LENGTH_DESCENDING =Film.LENGTH.reversed();@Benchmark
public long filterAndCount() {return films.stream().filter(RATING_EQUALS_PG_13).count();
}@Benchmark
public IntSummaryStatistics complex() {return films.stream().sorted(LENGTH_DESCENDING).skip(745).limit(5).mapToInt(Film.RENTAL_DURATION.asInt()).summaryStatistics();
}

以下设置用于单线程延迟测量：

# JMH version: 1.21
# VM version: JDK 10, Java HotSpot(TM) 64-Bit Server VM, 10+46
# VM invoker: /Library/Java/JavaVirtualMachines/jdk-10.jdk/Contents/Home/bin/java
# VM options: -javaagent:/Applications/IntelliJ IDEA CE.app/Contents/lib/idea_rt.jar=63173:/Applications/IntelliJ IDEA CE.app/Contents/bin -Dfile.encoding=UTF-8
# Warmup: 5 iterations, 10 s each
# Measurement: 5 iterations, 10 s each
# Timeout: 10 min per iteration
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: com.example.Bench.complex

使用SQL与MySQL数据库进行流传输

对我的笔记本电脑（MacBook Pro，2015年中，2.2 GHz Intel Core i7，16 GB RAM）上的标准MySQL数据库（版本5.7.16）运行这些查询将产生以下输出：

SINGLE-THREADED LATENCY (Lower is better)
Benchmark             Mode  Cnt  Score    Error  Units
Bench.complex         avgt    5  0.003 ±  0.001   s/op
Bench.filterAndCount  avgt    5  0.001 ±  0.001   s/opMULTI-THREADED THROUGHPUT (Higher is better)
Benchmark              Mode  Cnt     Score     Error  Units
Bench.complex         thrpt    5  1714.980 ± 343.655  ops/s
Bench.filterAndCount  thrpt    5  3154.984 ± 318.881  ops/s

使用MySQL数据库中的JVM内存加速功能进行流传输

启用JVM内存中加速并在笔记本电脑上再次运行相同的基准测试，将产生以下结果：

SINGLE-THREADED LATENCY (Lower is better)
Benchmark             Mode  Cnt   Score    Error  Units
Bench.complex         avgt    5  ≈ 10⁻⁶            s/op
Bench.filterAndCount  avgt    5  ≈ 10⁻⁷            s/opMULTI-THREADED THROUGHPUT (Higher is better)
Benchmark              Mode  Cnt         Score         Error  Units
Bench.complex         thrpt    5   4793915.881 ±  374680.158  ops/s
Bench.filterAndCount  thrpt    5  16958800.191 ± 1023015.568  ops/s

在一台旧笔记本电脑上每秒能够产生和消耗近1700万个视频流的能力真是令人惊讶。 具有许多CPU内核的现代服务器级计算机将很容易每秒能够产生和消耗超过2500万个流。

延迟的JMH时间分辨率不足以衡量足够的准确性。 通过使用一个线程运行吞吐量测试并将结果取反，平均“过滤器和计数”延迟估计为1 / 5,564,678 = 180 ns。 这种更准确的等待时间估算可提供大约5,000而非10,000的估算性能提升因子。

结论

启用JVM中的内存加速可以大大提高性能。 在上述基准测试中：

单线程延迟减少了以下因素：

复合体：约3,000

筛选和计数：〜5,000

多线程吞吐量增加了以下因素：

综合楼：2,700

筛选和计数：5,300

作为说明，这意味着具有一百万个子查询的复合JVM操作会将其聚合数据延迟从1小时减少到1秒。

笔记

为了提高SQL性能，将流（自动）呈现给SQL查询。 呈现的“过滤并计数” SQL查询如下所示：

SELECT COUNT(*) FROM (SELECT `film_id`,`title`,`description`,`release_year`, `language_id`,`original_language_id`,`rental_duration`,`rental_rate`, `length`,`replacement_cost`,`rating`,`special_features`,`last_update` FROM`sakila`.`film` WHERE (`rating`  = ? COLLATE utf8_bin)
) AS A
, values:[PG-13]

评分列中定义了一个索引。

可以看出，所有计数都是在数据库端完成的，并且该流没有将任何不必要的Film对象从数据库拉入JMH应用程序。

源代码

可以在此处查看基准测试的源代码。

摘要

在本文中，您学习了如何使用Speedment Free显着减少数据分析Java应用程序中的延迟，同时提高吞吐量。

加速因素是几个数量级。

翻译自: https://www.javacodegeeks.com/2018/09/ultra-low-latency-querying-with-java-streams-and-in-jvm-memory.html

java-jar jvm