Skip to content

A
apachecn-java-zh

OpenDocCN / apachecn-java-zh
11 个月 前同步成功

通知 5
Star 53
Fork 13
A
apachecn-java-zh

体验新版 GitCode，发现更多精彩内容 >>

提交 51d73b2d 编写于 作者: W wizardforcel
浏览文件
操作

2021-04-10 23:40:10

上级 98b778ec
展开全部 隐藏空白更改
内联 并排
Showing with 998 addition and 999 deletion
new/master-java11/00.md
浏览文件 @ 51d73b2d
......@@ -12,39 +12,39 @@ Java11 及其新特性增加了语言的丰富性，这是构建健壮软件应
# 这本书的内容
[第一章](01.html)*java11 场景*，探讨了 Java 平台上新实现的基于时间的版本控制系统。我们调查了当前的 Java 环境，特别关注 Java9、10（18.3）和 11（18.9）带来的变化。我们的探索包括对 Java9 的模块化、Javashell、外部进程控制、垃圾收集、JHM 等的概述。对于 Java10，我们将重点介绍关键更改，包括局部变量类型推断、JDK 整合、垃圾收集、应用程序类数据共享和根证书等。最后，我们将探讨 Java11 中引入的更改，包括动态类文件常量、垃圾收集和 lambdas 的局部变量类型推断。
[第一章](01.html)*java11 场景*探讨了 Java 平台上新实现的基于时间的版本控制系统。我们调查了当前的 Java 环境，特别关注 Java9、10（18.3）和 11（18.9）带来的变化。我们的探索包括对 Java9 的模块化、Javashell、外部进程控制、垃圾收集、JHM 等的概述。对于 Java10，我们将重点介绍关键更改，包括局部变量类型推断、JDK 整合、垃圾收集、应用程序类数据共享和根证书等。最后，我们将探讨 Java11 中引入的更改，包括动态类文件常量、垃圾收集和 lambdas 的局部变量类型推断。
[第二章](02.html)*发现 Java 11*，关注 Java 平台中引入的几个内部变化，包括 Java 9、10 和 11 的变化。Java 9 代表 Java 平台的主要版本；Java 10 和 11 是定时版本。总的来说，这些版本包含了大量的内部更改，为 Java 开发人员提供了一系列新的可能性，有些源于开发人员的请求，有些源于 Oracle 的增强
[第 2 章](02.html)*发现 Java 11*，关注 Java 平台中引入的几个内部变化，包括 Java 9、10 和 11 的变化。Java 9 代表 Java 平台的主要版本；Java 10 和 11 是定时版本。总的来说，这些版本包含了大量的内部更改，为 Java 开发人员提供了一系列新的可能性，有些源于开发人员的请求，有些源于 Oracle 的增强
[第 3 章](03.html)，*Java 11 基础*，涵盖了影响变量处理程序的 Java 平台变更、导入语句、Project Coin 改进、局部变量类型推断、根证书、动态类文件常量等。这些表示对 Java 语言本身的更改。
[第 3 章](03.html)*Java 11 基础*，介绍了影响变量处理程序的 Java 平台变更、导入语句、Project Coin 改进、局部变量类型推断、根证书、动态类文件常量等。这些表示对 Java 语言本身的更改。
[第 4 章](04.html)*使用 Java 11*构建模块化应用程序，分析了 Jigsaw 项目指定的 Java 模块的结构，深入探讨了 Jigsaw 项目作为 Java 平台的一部分是如何实现的。我们还回顾了 Java 平台与模块化系统相关的关键内部更改。
[第 4 章](04.html)*使用 Java11*构建模块化应用程序，分析了 Jigsaw 项目指定的 Java 模块的结构，深入探讨了 Jigsaw 项目作为 Java 平台的一部分是如何实现的。我们还回顾了 Java 平台与模块化系统相关的关键内部更改。
[第 5 章](05.html)*将应用迁移到 Java 11*，探讨如何将现有的应用迁移到当前的 Java 平台。我们将研究手动和半自动迁移过程。本章旨在为您提供一些见解和过程，使您的非模块化 Java 代码能够在当前的 Java 平台上工作。
[第 5 章](05.html)*将应用程序迁移到 Java 11*，探讨如何将现有的应用程序迁移到当前的 Java 平台。我们将研究手动和半自动迁移过程。本章旨在为您提供一些见解和过程，使您的非模块化 Java 代码能够在当前的 Java 平台上工作。
[第 6 章](06.html)*在试用 Java Shell*的时候，看一下新的命令行，Java 中的**Read Eval Print Loop**（也称为**REPL**）工具，还有**Java Shell**（**JShell**）。我们从介绍该工具、REPL 概念开始，然后进入 JShell 使用的命令和命令行选项。我们采用实践者的方法来回顾 JShell，并包含一些您可以自己尝试的示例。
[第 6 章](06.html)*实验了 Java Shell*，介绍了新的命令行，Java 中的**Read Eval Print Loop**（也称为**REPL**工具，以及**Java Shell**（**JShell**）。我们从介绍该工具、REPL 概念开始，然后进入 JShell 使用的命令和命令行选项。我们采用实践者的方法来回顾 JShell，并包含一些您可以自己尝试的示例。
[第 7 章](07.html)*利用默认的 G1 垃圾收集器*，深入研究了垃圾收集以及 Java 中如何处理垃圾收集。我们从垃圾收集的概述开始，然后看看 Java9 之前的领域中的细节。有了这些基本信息，我们就来看看 Java9 平台中具体的垃圾收集更改。最后，我们来看一些即使在 Java11 之后仍然存在的垃圾收集问题。
[第 7 章](07.html)*利用了默认的 G1 垃圾收集器*，深入研究了垃圾收集及其在 Java 中的处理方式。我们从垃圾收集的概述开始，然后看看 Java9 之前的领域中的细节。有了这些基本信息，我们就来看看 Java9 平台中具体的垃圾收集更改。最后，我们来看一些即使在 Java11 之后仍然存在的垃圾收集问题。
[第 8 章](08.html)*使用 JMH*的微基准应用程序，介绍如何使用**Java 微基准线束**（**JMH**）编写性能测试，这是一个 Java 线束库，用于为**Java 虚拟机**（**JVM**编写基准测试。我们使用 Maven 和 JMH 来帮助说明使用新 Java 平台进行微标记的威力。
[第 8 章](08.html)*使用 JMH*的微基准应用程序，介绍如何使用**Java 微基准线束**（**JMH**）编写性能测试，这是一个用于为**Java 虚拟机**（**JVM**编写基准测试的 Java 线束库。我们使用 Maven 和 JMH 来帮助说明使用新 Java 平台进行微标记的威力。
[第 9 章](09.html)*利用流程 API*，重点介绍了`Process`类和`java.lang.ProcessHandle`API 的更新。在 Java 的早期版本中，在 Java9 之前，用 Java 管理进程是很困难的。API 不够，有些功能不够，有些任务需要以特定于系统的方式来解决。例如，在 Java8 中，给一个进程访问它自己的**进程标识符**（**PID**）是一项不必要的困难任务。
[第 9 章](09.html)*利用流程 API*，重点介绍了`Process`类和`java.lang.ProcessHandle`API 的更新。在 Java 的早期版本中，在 Java9 之前，用 Java 管理进程是很困难的。API 不够，有些功能不够，有些任务需要以特定于系统的方式来解决。例如，在 Java8 中，让进程访问自己的**进程标识符**（**PID**）是一项不必要的困难任务。
[第 10 章](10.html)，*细粒度堆栈跟踪**ing*，重点介绍 Java 的`StackWalker`API。API 支持普通程序很少需要的特殊功能。API 在一些非常特殊的情况下非常有用，比如框架提供的功能。因此，如果您想要一种有效的堆栈遍历方法，使您能够对堆栈跟踪信息进行可过滤的访问，那么您将喜欢使用`StackWalker`API。该 API 提供对调用堆栈的快速优化访问，实现对单个帧的延迟访问。
[第 10 章](10.html)*细粒度堆栈跟踪**ing*，重点介绍 Java 的`StackWalker`API。API 支持普通程序很少需要的特殊功能。API 在一些非常特殊的情况下非常有用，比如框架提供的功能。因此，如果您想要一种有效的堆栈遍历方法，使您能够对堆栈跟踪信息进行可过滤的访问，那么您将喜欢使用`StackWalker`API。该 API 提供对调用堆栈的快速优化访问，实现对单个帧的延迟访问。
[第 11 章](11.html)*新工具和工具增强*，涵盖了十几种与现代 Java 平台相关的工具和工具增强。这些特色的变化将涵盖广泛的工具和 api 的更新，这些工具和 api 旨在简化 Java 开发，增强创建优化 Java 应用程序的能力。
[第 12 章](12.html)、*并发增强*介绍了 Java 平台的并发增强。我们主要关注的是对反应式编程的支持，这是一种由`Flow`类 API 提供的并发增强。反应式编程最初是在 Java9 中发布的，它仍然是 Java10 和 Java11 的一个重要特性。
[第 12 章](12.html)*并发增强*介绍了 Java 平台的并发增强。我们主要关注的是对反应式编程的支持，这是一种由`Flow`类 API 提供的并发增强。反应式编程最初是在 Java9 中发布的，它仍然是 Java10 和 Java11 的一个重要特性。
[第 13 章](13.html)*安全增强*介绍了最近对 JDK 所做的几个涉及安全性的更改，这些更改的大小并不反映其重要性。现代 Java 平台的安全性增强为开发人员提供了编写和维护比以前更安全的应用程序的能力。
[第 13 章](13.html)*安全增强*介绍了最近对 JDK 进行的几个涉及安全性的更改，这些更改的大小并没有反映出它们的重要性。现代 Java 平台的安全性增强为开发人员提供了编写和维护比以前更安全的应用程序的能力。
[第 14 章](14.html)*命令行标志*，探讨了现代 Java 平台的一些变化，这些变化的共同主题是命令行标志。这些包括以下概念：统一 JVM 日志、编译器控制、诊断命令、堆分析代理、删除 JHAT、命令行标志参数验证、针对旧平台版本的编译，以及实验性的基于 Java 的 JIT 编译器。
[第 15 章](15.html)*Java 平台的附加增强*，重点介绍 Java 平台提供的附加实用程序的最佳实践。具体来说，本章介绍对 UTF-8、Unicode 支持、Linux/AArch64 端口、多分辨率图像和公共区域设置数据存储库的支持。
[第 16 章](16.html)*未来方向*概述了 Java 平台在 Java11 之外的未来发展。我们看一下 Java19.3 和 19.9 的计划内容，以及将来可能会看到哪些进一步的变化。我们首先简要介绍一下**JDK 增强程序**（**JEP**）。
[第 16 章](16.html)*未来方向*概述了 Java 平台在 java11 之外的未来发展。我们看一下 Java19.3 和 19.9 的计划内容，以及将来可能会看到哪些进一步的变化。我们首先简要介绍一下**JDK 增强程序**（**JEP**）。
[第 17 章](17.html)*对 Java 平台的贡献*，讨论 Java 社区和开发人员对 Java 平台的贡献方式。具体来说，本章涵盖了以下与 Java 社区相关的主题，如 Java 社区、参与 Java 用户组、Java 社区过程、**Oracle 技术网络**（**OTN**）以及撰写技术文章
[第 17 章](17.html)*对 Java 平台的贡献*，讨论了 Java 社区和开发人员对 Java 平台的贡献方式。具体来说，本章涵盖了以下与 Java 社区相关的主题，如 Java 社区、参与 Java 用户组、Java 社区过程、**Oracle 技术网络**（**OTN**）以及撰写技术文章
# 充分利用这本书
......@@ -52,11 +52,11 @@ Java11 及其新特性增加了语言的丰富性，这是构建健壮软件应
# 下载示例代码文件
您可以从您的帐户[下载本书的示例代码文件 www.packt.com](http://www.packt.com) . 如果您在别处购买了这本书，您可以访问[www.packt.com/support](http://www.packt.com/support) 注册后直接将文件通过电子邮件发送给您。
您可以从您的帐户[下载本书的示例代码文件 www.packt.com](http://www.packt.com)。如果您在其他地方购买了本书，您可以访问[www.packt.com/support](http://www.packt.com/support)并注册，将文件直接通过电子邮件发送给您。
您可以通过以下步骤下载代码文件：
1. 在[登录或注册 www.packt.com](http://www.packt.com) .
1. 在[登录或注册 www.packt.com](http://www.packt.com)。
2. 选择“支持”选项卡。
3. 点击代码下载和勘误表。
4. 在搜索框中输入图书名称，然后按照屏幕上的说明进行操作。
......@@ -67,19 +67,19 @@ Java11 及其新特性增加了语言的丰富性，这是构建健壮软件应
* Mac 的 Zipeg/iZip/UnRarX
* 用于 Linux 的 7-Zip/PeaZip
该书的代码包也托管在 GitHub 上的[https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition](https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition) 。如果代码有更新，它将在现有 GitHub 存储库中更新。
这本书的代码包也托管在 GitHub 上的[https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition](https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition)。如果代码有更新，它将在现有 GitHub 存储库中更新。
我们的丰富书籍和视频目录还提供了其他代码包，请访问**[https://github.com/PacktPublishing/](https://github.com/PacktPublishing/)** . 看看他们！
我们的丰富书籍和视频目录中还有其他代码包，可在**[上找到 https://github.com/PacktPublishing/](https://github.com/PacktPublishing/)**。看看他们！
# 下载彩色图像
我们还提供了一个 PDF 文件，其中包含本书中使用的屏幕截图/图表的彩色图像。您可以在这里下载：[https://www.packtpub.com/sites/default/files/downloads/9781789137613\u ColorImages.pdf](https://www.packtpub.com/sites/default/files/downloads/9781789137613_ColorImages.pdf) .
我们还提供了一个 PDF 文件，其中包含本书中使用的屏幕截图/图表的彩色图像。您可以在这里下载：[https://www.packtpub.com/sites/default/files/downloads/9781789137613\u ColorImages.pdf](https://www.packtpub.com/sites/default/files/downloads/9781789137613_ColorImages.pdf)。
# 使用的约定
这本书中使用了许多文本约定。
`CodeInText`：表示文本中的码字、数据库表名、文件夹名、文件名、文件扩展名、路径名、伪 URL、用户输入和 Twitter 句柄。下面是一个示例：“将下载的[1]磁盘映像文件作为系统中的另一个磁盘装入。”
`CodeInText`：表示文本中的代码字、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 句柄。下面是一个示例：“将下载的`WebStorm-10*.dmg`磁盘映像文件作为系统中的另一个磁盘装入。”
代码块设置如下：
......@@ -103,7 +103,7 @@ public default void fastWalk() {
$ java --version
```
**粗体**：表示您在屏幕上看到的新术语、重要单词或单词。例如，菜单或对话框中的单词会像这样出现在文本中。下面是一个示例：“从管理面板中选择系统信息。”
**粗体**：表示一个新术语、一个重要单词或屏幕上显示的单词。例如，菜单或对话框中的单词会像这样出现在文本中。下面是一个示例：“从管理面板中选择系统信息。”
警告或重要提示如下所示。
......@@ -113,16 +113,16 @@ $ java --version
我们欢迎读者的反馈。
**一般反馈**：如果您对本书的任何方面有任何疑问，请在邮件主题中注明书名，并发送电子邮件至`customercare@packtpub.com`。
**总体反馈**：如果您对本书的任何方面有任何疑问，请在留言主题中注明书名，并发送电子邮件至`customercare@packtpub.com`。
**勘误表**：虽然我们已尽全力确保内容的准确性，但还是会出现错误。如果您在本书中发现错误，请向我们报告，我们将不胜感激。请访问[www.packt.com/submit-errata](http://www.packt.com/submit-errata) ，选择您的书籍，单击勘误表提交表单链接，然后输入详细信息。
**勘误表**：虽然我们已经尽一切努力确保内容的准确性，但还是会出现错误。如果您在本书中发现错误，请向我们报告，我们将不胜感激。请访问[www.packt.com/submit-errata](http://www.packt.com/submit-errata)，选择您的书籍，点击勘误表提交表单链接，输入详细信息。
**盗版**：如果您在互联网上遇到任何形式的非法复制品，请您提供我们的位置地址或网站名称，我们将不胜感激。请通过`copyright@packt.com`与我们联系，并提供该材料的链接。
**盗版**：如果您在互联网上遇到任何形式的非法复制我们的作品，请您提供我们的位置地址或网站名称，我们将不胜感激。请通过`copyright@packt.com`与我们联系，并提供该材料的链接。
**如果你有兴趣成为一名作家**：如果有一个你有专长的话题，你有兴趣写一本书或为一本书做贡献，请访问[作者.packtpub.com](http://authors.packtpub.com/) .
**如果你有兴趣成为一名作家**：如果有一个你有专长的话题，你有兴趣写一本书或为一本书做贡献，请访问[作者.packtpub.com](http://authors.packtpub.com/)。
# 评论
请留下评论。一旦你阅读并使用了这本书，为什么不在你购买它的网站上留下评论呢？潜在的读者可以看到并使用你的无偏见的意见作出购买决定，我们在 Packt 可以理解你对我们产品的看法，我们的作者可以看到你对他们的书的反馈。谢谢您！
有关 Packt 的更多信息，请访问[packt.com 网站](http://www.packt.com/) .
\ No newline at end of file
有关 Packt 的更多信息，请访问[packt.com 网站](http://www.packt.com/)。
\ No newline at end of file
new/master-java11/01.md
浏览文件 @ 51d73b2d
此差异已折叠。
new/master-java11/02.md
浏览文件 @ 51d73b2d
此差异已折叠。
new/master-java11/03.md
浏览文件 @ 51d73b2d
......@@ -19,15 +19,15 @@
# 技术要求
本章及后续章节主要介绍 Java 11，Java 平台的**标准版**（**SE**）可从 Oracle 官方下载网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html) ). 
本章及后续章节主要介绍 Java 11，Java 平台的**标准版**（**SE**）可从 Oracle 官方下载网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html)）
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 社区版可从网站（[下载 https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/) ).
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 的社区版可从网站（[下载 https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/)）。
本章的源代码可以在 GitHub 的 URL（[上找到 https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition](https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition) [).](https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition)
本章的源代码可以在 GitHub 的 URL（[上找到 https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition](https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition)[）。](https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition)
# 使用变量处理程序
变量处理程序是对变量的类型化引用，由`java.lang.invoke.VarHandle`抽象类控制。方法的签名是多态的。这使得方法签名和返回类型都具有很大的可变性。下面是一个代码示例，演示如何使用[2]：
变量处理程序是对变量的类型化引用，由`java.lang.invoke.VarHandle`抽象类控制。`VarHandle`方法的签名是多态的。这使得方法签名和返回类型都具有很大的可变性。下面是一个代码示例，演示如何使用`VarHandle`：
```
. . .
......@@ -67,19 +67,19 @@ class Sample {
此外，这种变化导致了内存排序和对象可达性的两种栅栏操作。本着尽职尽责的精神，特别注意确保 JVM 的安全。确保这些更改不会导致内存错误非常重要。数据完整性、可用性，当然还有性能是上述尽职调查的关键组成部分，解释如下：
* **安全性**：不能出现损坏的内存状态。
* **安全**：不能出现损坏的内存状态。
* **数据完整性**：必须确保对对象字段的访问使用相同的规则：
* `getfield`字节码
* `putfield`字节码
* **可用性**：可用性的基准是`sun.misc.Unsafe`API。目标是使新的 API 比基准更易于使用。
* **性能**：与使用`sun.misc.Unsafe`API 相比，性能不会下降。我们的目标是超越 API。
* **性能**：与`sun.misc.Unsafe`API 相比，性能无下降。目标是超越 API。
在 Java 中，fence 操作是 javac 以 barrier 指令的形式强制内存约束的操作。这些操作发生在屏障指令之前和之后，本质上是将它们封闭起来。
# 使用原子工具包
[0]包是 12 个子类的集合，支持对线程安全和无锁的单个变量执行操作。在此上下文中，线程安全是指访问或变异共享单个变量而不妨碍其他线程同时对该变量执行的代码。这个超类是在 Java7 中引入的。
`java.util.concurrent.atomic`包是 12 个子类的集合，它们支持对线程安全和无锁的单个变量的操作。在此上下文中，线程安全是指访问或变异共享单个变量而不妨碍其他线程同时对该变量执行的代码。这个超类是在 Java7 中引入的。
下面是原子工具箱中 12 个子类的列表。如您所料，类名是自描述性的：
......@@ -100,7 +100,7 @@ class Sample {
在 Java 中，`volatile`关键字用于通知 javac 实用程序从主存中读取值、字段或数组元素，而不是缓存它们。
下面是一段代码片段，演示了对实例变量使用[0]关键字：
下面是一段代码片段，演示了对实例变量使用`volatile`关键字：
```
public class Sample {
......@@ -128,7 +128,7 @@ instance
# 使用 sun.misc.不安全班
[0]类与其他[1]类一样，没有正式的文档记录或支持。它被用来规避 Java 的一些内置内存管理安全特性。虽然这可以看作是我们代码中实现更大控制和灵活性的窗口，但这是一种糟糕的编程实践。
`sun.misc.Unsafe`类和其他`sun`类一样，没有正式的文档记录或支持。它被用来规避 Java 的一些内置内存管理安全特性。虽然这可以看作是我们代码中实现更大控制和灵活性的窗口，但这是一种糟糕的编程实践。
该类只有一个私有构造函数，因此无法轻松实例化该类的实例。所以，如果我们尝试用`myUnsafe = new Unsafe()`实例化一个实例，在大多数情况下都会抛出`SecurityException`。这个有些不可访问的类有 100 多个方法，允许对数组、类和对象进行操作。以下是这些方法的简单示例：
......@@ -140,7 +140,7 @@ instance
以下是用于信息、内存和同步的`sun.misc.Unsafe`类方法的第二个分组：
| **信息** | **内存** | **同步** |
| **信息** | **存储器** | **同步** |
| `addressSize` | `allocateMemory` | `compareAndSwapInt` |
| `pageSize` | `copyMemory` | `monitorEnter` |
| | `freeMemory` | `monitorExit` |
......@@ -162,8 +162,8 @@ Java9 略微减少了我们收到的警告数量。特别是，不再生成由
现在，如果以下一种或多种情况为真，编译器将抑制折旧警告：
* 如果使用`@Deprecated`注解
* 如果使用`@SuppressWarnings`注解
* 如果使用`@Deprecated`注释
* 如果使用`@SuppressWarnings`注释
* 如果警告生成代码和声明的使用在祖先类中
* 如果警告生成代码的使用在`import`语句中
......@@ -177,16 +177,16 @@ projectcoin 是 java7 中引入的一组小改动的特性集。这些变化如
* 实施多重捕获
* 允许更精确地重新触发异常
* 通用实例创建改进
* 添加[0]-with resource 语句
* `try`—with resource 语句的添加
* 调用`varargs`方法的改进
详细信息见以下 Oracle 演示文稿（[http://www.oracle.com/us/technologies/java/project-coin-428201.pdf](http://www.oracle.com/us/technologies/java/project-coin-428201.pdf) ).
详细信息见以下 Oracle 演示（[http://www.oracle.com/us/technologies/java/project-coin-428201.pdf](http://www.oracle.com/us/technologies/java/project-coin-428201.pdf)）。
对于 Java9 版本，ProjectCoin 有五个改进。这些增强功能将在下面的部分中详细介绍。
# 使用@SafeVarargs 注释
从 Java9 开始，我们可以对私有实例方法使用[0]注释。当我们使用这个注释时，我们断言这个方法不包含对作为参数传递给这个方法的`varargs`的任何有害操作。
从 Java9 开始，我们可以将`@SafeVarargs`注释与私有实例方法结合使用。当我们使用这个注释时，我们断言这个方法不包含对作为参数传递给这个方法的`varargs`的任何有害操作。
使用的语法如下：
......@@ -202,7 +202,7 @@ static void methodName(...) {
}
```
`@SafeVarargs`注释仅限于以下用途：
`@SafeVarargs`注释的使用仅限于以下内容：
* 静态方法
* 终审方法
......@@ -210,7 +210,7 @@ static void methodName(...) {
# try with resource 语句
以前使用`final`变量时，`try`-with resource 语句要求为语句中的每个资源声明一个新变量。以下是 Java9 之前的[2]-with resource 语句的语法（在 Java7 或 Java8 中）：
`try`-with resource 语句以前要求在使用`final`变量时为语句中的每个资源声明一个新变量。以下是 Java9 之前的`try`-with resource 语句的语法（在 Java7 或 Java8 中）：
```
try ( // open resources ) {
......@@ -234,7 +234,7 @@ try ( Scanner xmlScanner = new Scanner(new File(xmlFile)); {
}
```
自 Java9 以来，`try`-with resource 语句可以管理`final`个变量，而不需要新的变量声明。因此，我们现在可以用 Java 9、10 或 11 重写前面的代码，如下所示：
自 Java9 以来，`try`with resource 语句可以管理`final`变量，而不需要新的变量声明。因此，我们现在可以重写 Java9、10 或 11 中的早期代码，如图所示：
```
Scanner xmlScanner = new Scanner(newFile(xmlFile));
......@@ -248,15 +248,15 @@ try ( while (xmlScanner.hasNext()) {
}
```
如您所见，`xmlScanner`对象引用包含在`try`—with resource 语句块中，它提供了自动资源管理。一旦`try`-with resource 语句块退出，资源将自动关闭。
如您所见，`xmlScanner`对象引用包含在`try`-with resource 语句块中，它提供了自动资源管理。一旦退出`try`-with resource 语句块，资源将自动关闭。
您也可以将[0]块用作[1]-with resource 语句的一部分。
您也可以使用`finally`块作为`try`-with resource 语句的一部分。
# 使用菱形运算符
java9 中引入了 diamond 操作符，如果推断的数据类型是可表示的，那么 diamond 操作符可以用于匿名类。当推断出数据类型时，它表明 Java 编译器可以确定方法调用中的数据类型。这包括声明和其中包含的任何参数。
菱形运算符是小于和大于符号对（`<>`），它对 Java9 来说并不新鲜；相反，匿名类的具体用法是。
菱形运算符是小于和大于符号对（`<>`），它对 Java9 并不陌生，相反，匿名类的具体用法是。
diamond 操作符是在 java7 中引入的，它简化了泛型类的实例化。以下是 Java 7 之前的一个示例：
......@@ -313,7 +313,7 @@ Example example = new Example<>()
# 停止使用下划线
下划线字符（[0]）不能再用作合法的标识符名称。先前删除标识符名称中下划线的尝试是不完整的。使用下划线将产生错误和警告的组合。自 Java9 以来，警告现在是错误。考虑以下示例代码：
下划线字符（`_`）不能再用作合法的标识符名称。先前删除标识符名称中下划线的尝试是不完整的。使用下划线将产生错误和警告的组合。自 Java9 以来，警告现在是错误。考虑以下示例代码：
```
public class UnderscoreTest {
......@@ -329,7 +329,7 @@ public class UnderscoreTest {
}
```
在 Java8 中，前面的代码将导致对[0]和[1]语句的编译器警告。警告是：`As of Java 9, '_' is a keyword, and may not be used as an identifier`。因此，在 Java9、10 或 11 中，不能单独使用下划线作为合法标识符。
在 Java8 中，前面的代码将导致针对`int _ = 319;`和`if ( _ > 300`语句的编译器警告。警告是：`As of Java 9, '_' is a keyword, and may not be used as an identifier`。因此，在 Java9、10 或 11 中，不能单独使用下划线作为合法标识符。
使用非自描述性的标识符名称被认为是不好的编程实践。因此，将下划线字符本身用作标识符名称不应该是一个有问题的更改。
......@@ -375,7 +375,7 @@ public interface characterTravel {
}
```
从 Java9 开始，我们可以重写这段代码。正如您在下面的代码段中看到的，多余的代码已经被移动到一个名为`characterTravel`的私有方法中：
从 Java9 开始，我们可以重写这段代码。正如您在下面的代码片段中所看到的，冗余代码已经被移动到一个名为`characterTravel`的私有方法中：
```
. . .
......@@ -425,14 +425,14 @@ public interface characterTravel {
# 导入报表处理
**JDK 增强方案**（**JEP】**216 是针对 javac 如何处理导入语句而发布的。在 Java9 之前，如果源代码是否被接受，导入语句的顺序会产生影响
**JDK 增强建议**（**JEP）**216 是针对 javac 如何处理导入语句而发布的。在 Java9 之前，如果源代码是否被接受，导入语句的顺序会产生影响
当我们用 Java 开发应用程序时，我们通常会根据需要添加 import 语句，从而导致 import 语句的无序列表。ide 在对未使用的导入语句进行颜色编码方面做得很好，还可以通知我们需要的导入语句，但这还没有包括在内。导入语句的顺序应该无关紧要；没有适用的层次结构
javac 编译类有两个主要步骤。具体到导入语句的处理，步骤如下：
* **类型解析**：类型解析包括对抽象语法树的检查，以识别类和接口的声明
* **成员解析**：成员解析包括确定类层次结构和单个类变量及成员
* **成员解析**：成员解析包括确定类的层次结构、单个类变量和成员
从 Java9 开始，我们在类和文件中列出 import 语句的顺序将不再影响编译过程。让我们看一个例子：
......@@ -464,12 +464,12 @@ public interface Inner {
下一步是成员解析，这就是 Java9 之前存在的问题所在。下面是 javac 将用于为我们的示例代码执行成员解析的连续步骤的概述：
1. `SamplePackage.OuterPackage`的解析开始。
2. 已处理[0]导入。
3. [0]类的解析开始。
2. 处理`SamplePackage.OuterPackage.Nested`导入。
3. `SamplePackage.Outer.Nested`课的决议开始。
4. 内部接口是经过类型检查的，但由于此时它不在范围内，因此无法解析内部接口。
5. `SamplePackage.Thing`的解析开始。此步骤包括将`SamplePackage.Thing`的所有成员类型导入范围。
因此，在我们的示例中，出现错误是因为尝试解析时[0]超出范围。如果把第 4 步和第 5 步互换，就不会有问题了。
因此，在我们的示例中，出现错误是因为在尝试解析时，`Inner`超出了范围。如果把第 4 步和第 5 步互换，就不会有问题了。
这个问题的解决方案是在 Java9 中实现的，它将成员解析步骤分解为额外的子步骤。以下是这些步骤：
......@@ -491,25 +491,25 @@ var myList = new ArrayList<String>();
前面的代码推断出了`ArrayList<String>`，因此我们不再需要使用详细的`ArrayList<String> myList = new ArrayList<String>();`语法。
引入[0]标识符不应解释为向 Java 语言中添加了一个[1]关键字。`var`标识符在技术上是一个保留的类型名
引入`var`标识符不应被解释为向 Java 语言中添加`new`关键字。`var`标识符在技术上是一个保留的类型名
使用[0]标识符有一些限制。例如，当存在以下任何一种情况时，不能使用它们：
使用`new`标识符有一些限制。例如，当存在以下任何一种情况时，不能使用它们：
* 未使用初始值设定项
* 正在声明多个变量
* 使用数组维度括号
* 使用对初始化变量的引用
如预期的那样，如果[0]使用不正确，javac 将发出特定的错误消息。
如预期的那样，如果`var`使用不正确，javac 将发出特定的错误消息。
# Lambda 参数的局部变量语法
如本章前面所讨论的，`var`标识符是在 Java10 中引入的。在最新版本 java11 中，`var`可以用在隐式类型的 Lambda 表达式中。以下是两个等效 Java 语句的示例：
正如本章前面所讨论的，`var`标识符是在 Java10 中引入的。在最新版本 java11 中，`var`可以用在隐式类型的 Lambda 表达式中。以下是两个等效 Java 语句的示例：
* `(object1, object2) -> object1.myMyethod(object2)`
* `(var object1, var object2) -> object1.myMethod(object2)`
在第一条语句中，没有使用[0]标识符。在第二个语句中，使用了`var`。需要注意的是，如果在隐式类型的 Lambda 表达式中使用了[2]，那么它必须用于所有形式参数。
在第一个语句中，不使用`var`标识符。在第二个语句中，使用了`var`。需要注意的是，如果在隐式类型的 Lambda 表达式中使用了`var`，则必须将其用于所有形式参数。
# 线程本地握手
......@@ -533,7 +533,7 @@ XX:AllocateHeapAt=<file system path>
# 根证书
从 Java10 的发布开始，有一组默认的**证书颁发机构**（**CA**）证书作为 JDK 的一部分。Java10 之前的 JDK 的`cacerts`和`keystore`不包含一组证书。在此 Java 版本之前，开发人员需要为`cacerts`和`keystore`创建和配置一组根证书
从 java10 的发布开始，JDK 中有一组默认的**证书颁发机构**（**CA**）证书。java10 之前的 JDK 的`cacerts`和`keystore`不包含一组证书。在此 Java 版本之前，开发人员需要为`cacerts`和`keystore`创建和配置一组根证书
现在，Java 平台在`cacerts`和`keystore`中包含了一组由 Oracle 颁发的根证书。特定 CA 是 javase 根 CA 程序的一部分。
......@@ -561,21 +561,21 @@ XX:AllocateHeapAt=<file system path>
# 动态类文件常量
在 Java11 中，Java 类文件的文件格式被扩展为支持`CONSTANT_Dynamic`，它将创建委托给引导方法。Java 平台中增加了一个新的常量形式`CONSTANT_Dynamic`，包含两个组件：
在 java11 中，Java 类文件的文件格式被扩展为支持`CONSTANT_Dynamic`，它将创建委托给 bootstrap 方法。Java 平台中增加了一个新的常量形式`CONSTANT_Dynamic`，它包含两个组件：
* `CONSTANT_InvokeDynamic`
* `CONSTANT_NameAndType`
有关此功能增强的更多详细信息，请参见本章*进一步阅读*部分中的链接。
有关此功能增强的更多细节，请按照本章*进一步阅读*部分的链接找到。
# 删除 javaee 和 CORBA 模块
**Java Enterprise Edition**（**Java****EE**）和**Common Object Request Broker Architecture**（**CORBA**）模块在 Java 9 中被折旧，从 Java 11 开始从 Java 平台中删除。
**Java Enterprise Edition**（**Java****EE**）和**Common Object Request Broker Architecture**（**CORBA**）模块在 Java 9 中被折旧，并从 Java 11 开始从 Java 平台中移除。
以下 Java SE 模块包含 Java EE 和 CORBA 模块，已被删除：
* 聚合器模块（`java.se.ee`）
* 常用批注（`java.xml.ws.annotation`）
* 常用注释（`java.xml.ws.annotation`
* CORBA（`java.corba`）
* JAF（`java.activation`）
* JAX-WS（`java.xml.ws`）
......@@ -594,7 +594,7 @@ XX:AllocateHeapAt=<file system path>
1. 什么是围栏作业？
2. 什么是硬币计划？
3. [0]可以与什么类型的方法一起使用？
3. `@SafeVarargs`可以与什么类型的方法一起使用？
4. 进口报表处理的变化有什么意义？
5. Java 在哪里存储根证书？
6. `var`不是关键字。这是怎么一回事？
......@@ -607,4 +607,4 @@ XX:AllocateHeapAt=<file system path>
下面列出的链接将帮助您深入了解本章介绍的概念：
* *学习 Java Lambdas*（[https://www.packtpub.com/application-development/learning-java-lambdas](https://www.packtpub.com/application-development/learning-java-lambdas) )
\ No newline at end of file
* *学习 Java Lambdas*（[https://www.packtpub.com/application-development/learning-java-lambdas](https://www.packtpub.com/application-development/learning-java-lambdas)
\ No newline at end of file
new/master-java11/04.md
浏览文件 @ 51d73b2d
......@@ -16,9 +16,9 @@
# 技术要求
本章及后续章节主要介绍 Java 11，Java 平台的**标准版**（**SE**）可从 Oracle 官方下载网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html) ).
本章及后续章节主要介绍 Java 11，Java 平台的**标准版**（**SE**）可从 Oracle 官方下载网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html)）。
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 的社区版可从网站（[下载 https://www.jetbrains.com/idea/features/)](https://www.jetbrains.com/idea/features/) .
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 的社区版可从网站（[下载 https://www.jetbrains.com/idea/features/)](https://www.jetbrains.com/idea/features/)。
# 模块化底漆
......@@ -33,7 +33,7 @@ IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章
* 我们的模块化代码可以更有针对性
* 更多地使用面向对象编程模型
* 还有其他封装的机会
* 我们的代码会更有效率
* 我们的代码将更高效
* Java 应用程序将提高性能
* 降低了整个系统的复杂性
* 测试和调试更容易
......@@ -44,8 +44,8 @@ Java 向模块化系统的转变是必要的，原因有几个。以下是 Java
* **Java 开发工具包**（**JDK**）实在太大了。这使得很难支持小型设备。即使在下一节讨论的紧凑配置文件中，支持一些小型设备充其量也是困难的，在某些情况下是不可能的
* 由于 JDK 过大，我们的 Java 应用程序很难支持真正优化的性能。在这种情况下，越小越好
* **Java 运行时环境**（**JRE**）太大，无法有效地测试和维护我们的 Java 应用程序。这将导致耗时、低效的测试和维护操作
* **Java 存档**（**JAR**文件）也太大。这使得支持小型设备成了问题
* 因为 JDK 和 JRE 包罗万象，所以安全性非常值得关注，例如 Java 应用程序没有使用的内部 api，由于 public access 修饰符的性质，仍然可用
* **Java 存档**（**JAR**文件也太大。这使得支持小型设备成了问题
* 由于 JDK 和 JRE 都是包罗万象的，所以安全性非常令人担忧，例如，Java 应用程序未使用的内部 API，由于公共访问修饰符的性质，仍然可用
* 最后，我们的 Java 应用程序太大了。
模块化系统具有以下要求：
......@@ -70,7 +70,7 @@ Java 向模块化系统的转变是必要的，原因有几个。以下是 Java
module com.three19.irisScan { }
```
模块声明包含在模块的`root`文件夹中的`module-info.java`文件中。正如人们所料，这个文件被编译成一个`module-info.class`文件，并将被放在适当的输出目录中。这些输出目录是在模块源代码中建立的
模块声明包含在`module-info.java`文件中，该文件应位于模块的`root`文件夹中。正如人们所料，这个文件被编译成一个`module-info.class`文件，并将被放在适当的输出目录中。这些输出目录是在模块源代码中建立的
在下一节中，我们将研究 Java 平台在模块化方面的具体变化。
......@@ -137,7 +137,7 @@ JEP-200 的核心目标是使用**Java 平台模块系统**（**JPMS**）对 JDK
这三个紧凑的模块概要文件代表了当前 Java 平台中标准化模块化系统的基础。标准化的有效性取决于以下六个原则：
* 所有受 JCP 管理的模块都必须以字符串`java`开头。因此，如果正在开发一个关于空间实用程序的模块，它的名称应该是`java.spatial.util`。
* 所有 JCP 管理的模块都必须以字符串`java`开头。因此，如果正在开发一个关于空间实用程序的模块，它的名称应该是`java.spatial.util`。
**JCP** refers to the **Java Community Process**. JCP allows developers to create technical specifications for Java. You can learn more about JCP and become a member at the official JCP website at [https://www.jcp.org/en/home/index](https://www.jcp.org/en/home/index).
......@@ -177,37 +177,37 @@ JDK 是代码文件、工具、库等的汇编。下图概述了 JDK 组件：
# 开发工具
开发工具位于`\bin`目录下。这些工具包括七个大的分类，每一个都将在后面的章节中详细介绍。
开发工具位于`\bin`目录中。这些工具包括七个大的分类，每一个都将在后面的章节中详细介绍。
# 部署
这是一组用于帮助部署 Java 应用程序的工具：
* `appletviewer`：此工具使您能够运行和调试 Java 小程序，而无需使用 web 浏览器。
* `extcheck`：此工具允许您在 JAR 文件中查找冲突。
* `appletviewer`：该工具使您能够运行和调试 Java 小程序，而无需使用 web 浏览器。
* `extcheck`：该工具允许您在 JAR 文件中查找冲突。
* `jar`：该工具用于创建和操作 JAR 文件。JAR 文件是 Java 存档文件。
* `java`：这是 Java 应用程序启动程序。
* `java`：这是 Java 应用程序启动器。
* `javac`：这是 Java 编译器。
* `javadoc`：此工具生成 API 文档。
* `javah`：此工具允许您编写本机方法；它生成 C 头文件。
* `javap`：此工具反汇编类文件。
* `javapackager`：用于签名和打包 Java 应用程序，包括 JavaFX。
* `javadoc`：该工具生成 API 文档。
* `javah`：这个工具允许您编写本机方法；它生成 C 头文件。
* `javap`：该工具反汇编类文件。
* `javapackager`：用于 Java 应用程序的签名和打包，包括 JavaFX。
* `jdb`：这是 Java 调试器。
* `jdeps`：这是一个 Java 类依赖的分析器。
* `pack200`：将 JAR 文件压缩成`pack200`文件的工具。使用这个工具的压缩比令人印象深刻。
* `unpack200`：此工具解压`pack200`个文件，生成 JAR 文件。
* `unpack200`：此工具解压`pack200`文件，生成 JAR 文件。
# 国际化
如果您对创建可本地化的应用程序感兴趣，以下工具可能会派上用场：
* `native2ascii`：此工具从普通文本创建 Unicode Latin-1
* `native2ascii`：该工具从普通文本创建 Unicode 拉丁-1
# 监测
用于提供 JVM 性能数据的监视工具包括：
* `jps`：JVM 进程状态工具（`jps`）。它提供了特定系统上热点 JVM 的列表。
* `jps`：这是 JVM 进程状态工具（`jps`）。它提供了特定系统上热点 JVM 的列表。
* `jstat`：JVM 统计监控工具。它从具有热点 JVM 的机器收集日志数据和性能信息。
* `jstatd`：这是`jstat`守护程序工具。它运行一个 RMI 服务器应用程序来监视热点 JVM 操作。
......@@ -216,9 +216,9 @@ JDK 是代码文件、工具、库等的汇编。下图概述了 JDK 组件：
**RMI**工具是**远程方法调用**工具。它们帮助开发人员创建通过网络运行的应用程序，包括互联网：
* `rmic`：该工具可以为网络上的对象生成存根和骨架
* `rmiregistry`：远程对象的注册服务
* `rmiregistry`：这是一个远程对象的注册服务
* `rmid`：此工具是 RMI 的激活系统守护程序
* `serialver`：返回类`serialVersionUID`值
* `serialver`：此工具返回类`serialVersionUID`值
# 安全
......@@ -242,11 +242,11 @@ JDK 是代码文件、工具、库等的汇编。下图概述了 JDK 组件：
这组工具提供了一个实用工具，可与**Java Web Start**和其他 Web 服务一起使用：
* `javaws`：这是一个启动 Java Web Start 的命令行工具。
* `javaws`：这是一个启动 JavaWebStart 的命令行工具。
* `schemagen`：该工具为 Java 架构生成模式。这些模式用于 XML 绑定。
* `wsgen`：此工具用于生成可移植的 JAX-WS 工件。
* `wsimport`：此工具用于导入可移植 JAX-WS 工件。
* `xjc`：用于 XML 绑定的绑定编译器。
* `wsgen`：该工具用于生成可移植的 JAX-WS 工件。
* `wsimport`：这个工具用于导入可移植的 JAX-WS 工件。
* `xjc`：这是用于 XML 绑定的绑定编译器。
# JavaFX 工具
......@@ -278,7 +278,7 @@ src/share/classes/...
src/share/classes/java/...
```
接下来，我们有 javaapi 包的名称，后跟文件扩展名。文件扩展名取决于`.java`、`.c`等内容。
接下来，我们有 javaapi 包的名称，后跟文件扩展名。文件扩展名依赖于`.java`、`.c`等内容。
# 图书馆
......@@ -286,20 +286,20 @@ src/share/classes/java/...
![](img/21c27de9-b47f-436c-8c76-e3002770ff89.png)
查看目录列表并不能提供很好的细粒度洞察力。我们可以使用以下命令列出`.jar`文件中包含的类：`jar tvf fileName.jar`。例如，下面是在命令行执行`jar tvf javafx-mx.jar`生成的类列表：
查看目录列表并不能提供很好的细粒度洞察力。我们可以使用以下命令列出任何一个`.jar`文件中包含的类：`jar tvf fileName.jar`。例如，下面是在命令行执行`jar tvf javafx-mx.jar`生成的类列表：
![](img/4354da68-104c-483d-9382-5013031bc7ab.png)
# C 头文件
[0]目录包含 C 头文件。这些文件主要支持以下内容：
`/include`目录包含 C 头文件。这些文件主要支持以下内容：
* **Java 本机接口（JNI）**：用于本机代码编程支持，JNI 用于将 Java 本机方法和 JVM 嵌入到本机应用中。
* **JVM 工具接口（JVM TI）**：用于对运行 JVM 的应用程序进行状态检查和执行控制的工具。
# 数据库
ApacheDerby 关系数据库存储在`/db`目录中。您可以在以下站点了解有关 Java DB 的更多信息：
apachederby 关系数据库存储在`/db`目录中。您可以在以下站点了解有关 Java DB 的更多信息：
* [http://docs.oracle.com/javadb/support/overview.html](https://docs.oracle.com/javadb/support/overview.html)
* [http://db.apache.org/derby/manuals/#docs_.11](http://db.apache.org/derby/manuals/#docs_10.11)
......@@ -330,7 +330,7 @@ Java9 中引入的 Java 模块化系统需要更改运行时映像以实现兼
这些更改的核心是用于资源命名的新 URI 模式。这些资源包括模块和类。
**统一资源标识符**（**URI****与**URL**（**统一资源定位器**）相似，它标识某物的名称和位置，对于 URL，某物是网页；对于 URI，它是资源。**
**统一资源标识符**（**URI****与**URL**（**统一资源定位器**）相似，它标识某物的名称和位置。对于 URL，某物是网页；对于 URI，它是资源。**
**JEP-220 有五个主要目标，这些目标将在下面的章节中详细介绍。
......@@ -340,7 +340,7 @@ Java9 中引入的 Java 模块化系统需要更改运行时映像以实现兼
* 当新的运行时格式比 java9jar 之前的格式具有更高的效率（时间和空间）时。
**JAR**文件是**Java 存档**文件。这是一种基于传统 ZIP 格式的压缩文件格式。
**JAR**文件是**Java 归档**文件。这是一种基于传统 ZIP 格式的压缩文件格式。
* 当存储的类和其他资源可以单独隔离和加载时。
* 当 JDK 和库类和资源可以存储时。这也包括应用程序模块。
......@@ -352,13 +352,13 @@ Java 中有两种类型的运行时映像：JDK 和 JRE。从 Java9 开始，这
在 Java9 之前的 JDK 构建系统同时生成了 JRE 和 JDK。JRE 是 Java 平台的完整实现。JDK 包括 JRE 以及其他工具和库。Java9 中一个显著的变化是 JRE 子目录不再是 JDK 映像的一部分。进行此更改的部分原因是为了确保两种图像类型（JDK 和 JRE）具有相同的图像结构。有了共同和重组的结构，未来的变革将更有效地结合起来。
如果您在 Java9 之前创建了针对特定结构的自定义插件，那么您的应用程序可能无法在 Java9 中工作。如果显式寻址[0]，也是这样。
如果您在 Java9 之前创建了针对特定结构的自定义插件，那么您的应用程序可能无法在 Java9 中工作。如果您显式地寻址`tools.jar`，这也是正确的。
下图提供了 Java 9 发布前每个图像内容的高级视图：
![](img/e1b55a00-4ec3-43d3-be69-d9ed4a7b07d9.jpg)
Java9 运行时映像如下图所示。如图所示，完整的 JDK 映像包含与模块化运行时映像相同的目录以及`demo`、`sample`、`man`，并且包含目录：
Java9 运行时映像如下图所示。如图所示，完整的 JDK 映像包含与模块化运行时映像相同的目录以及`demo`、`sample`、`man`，并且包括目录：
![](img/b6355c6c-6223-4abc-88f4-183cc41ba2cd.jpg)
......@@ -413,7 +413,7 @@ module com.three19.irisScan
让我们仔细看看前面的语法。`<source-module>`和`<targetmodule>`是模块名，`<package>`是包名。使用`add-exports`选项允许我们违反访问控制边界。
使用`add-exports`选项有两条规则：
关于使用`add-exports`选项有两条规则：
* 它可以在一个模块中多次使用
* 每次使用必须是`<source-module>`和`<targetmodule>`的唯一配对
......@@ -434,13 +434,13 @@ module com.three19.irisScan
# 模块化 Java 应用程序打包
Java9 以及 Java10 和 Java11 的最大改进之一是由**Java 打包程序**生成的运行时二进制文件的大小。部分原因是由于**Java 链接器**，这将在下一节中介绍。在当前的 Java11 中，JavaPackager 的工作流程基本上与 Java8 中的相同。您将在本节后面看到，工作流中添加了新工具。
Java9 以及 Java10 和 Java11 的最大改进之一是由**Java 打包程序**生成的运行时二进制文件的大小。这在一定程度上是由于**Java 链接器**的缘故，这将在下一节中介绍。在当前的 Java11 中，JavaPackager 的工作流程基本上与 Java8 中的相同。您将在本节后面看到，工作流中添加了新工具。
Java 打包程序只创建 JDK 应用程序。对 Java Packager 的这一更改旨在简化并提高生成运行时映像的过程的效率。因此，Java Packager 将只为与其关联的 SDK 版本创建运行时映像。
# Java 链接器的高级研究
在 Java9 中引入 Java 链接器工具`jlink`之前，运行时映像创建包括复制整个 JRE。然后，移除未使用的组件。简单地说，`jlink`有助于只使用所需模块创建运行时映像。`jlink` 由 Java 打包程序用来生成嵌入式运行时映像。
在 Java9 中引入 Java 链接器工具`jlink`之前，运行时映像创建包括复制整个 JRE。然后，移除未使用的组件。简单地说，`jlink`促进了只使用所需模块创建运行时映像。`jlink`被 Java 打包程序用来生成嵌入式运行时映像。
# Java 打包程序选项
......@@ -471,7 +471,7 @@ javapackager -command [-options]
![](img/2a3a8cf8-94fa-4c68-94f4-d2b9c77da037.png)
`-deploy`命令的剩余`[-options]`集包括：
`-deploy`命令的剩余`[-options]`集合包括以下内容：
![](img/a20fbfb3-e0be-4721-aa19-69a4a264c72d.png)
......@@ -490,17 +490,17 @@ Java Packager 分为两个模块：
# Java 链接器
Java 链接器（通常称为 JLink）是一种创建用于创建自定义运行时映像的工具。此工具收集适当的模块及其依赖项，然后优化它们以创建映像。随着 Java9 的发布，这代表了 Java 的一个巨大变化。在 Java 链接器工具 JLink 可用之前，运行时映像创建包括最初复制整个 JRE。在随后的步骤中，移除了未使用的组件。在当前的 Java 平台中，`jlink`只使用所需的模块创建运行时映像，`jlink`被 Java 打包程序用来生成嵌入式运行时映像。
Java 链接器，通常称为 JLink，是一个创建自定义运行时映像的工具。该工具收集相应的模块及其依赖项，然后对它们进行优化以创建映像。这代表了 Java 的一个重大变化，它将在 Java9 的发行版中实现。在 Java 链接器工具 JLink 可用之前，运行时映像创建包括最初复制整个 JRE。在随后的步骤中，将删除未使用的组件。在当前的 Java 平台中，`jlink`只创建需要的模块的运行时映像。`jlink`由 Java 打包程序生成嵌入式运行时映像。
如前一节所示，最近对 Java 平台的更改导致链接时成为编译时和运行时之间的可选阶段。正是在这个阶段，适当的模块被组装成一个优化的运行时映像。
JLink 是一个命令行链接工具，它允许创建包含较小 JDK 模块子集的运行时映像。这将导致更小的运行时映像。以下语法由四个组件组成：`jlink`命令、选项、模块路径和输出路径：
JLink 是一个命令行链接工具，它允许创建包含较小 JDK 模块子集的运行时映像。这将导致更小的运行时映像。以下语法由四个组件组成`jlink`命令、选项、模块路径和输出路径：
```
$ jlink <options> ---module-path <modulepath> --output <path>
```
以下是可与[0]工具一起使用的选项列表，以及每个选项的简要说明：
以下是可与`jlink`工具一起使用的选项列表，以及每个选项的简要说明：
![](img/f16c6d54-7178-4dc9-a001-8b40449d55cb.png)
......@@ -521,9 +521,9 @@ JEP-260 的实现使 Java 平台更加安全。JEP 的核心目标是封装大
* `sun.reflect.Reflection`
* `sun.reflect.ReflectionFactory.newConstrutorForSerialization`
上述关键的内部 api 在当前 Java 平台中仍然可以访问。它们可以通过`jdk.unsupported`JDK 模块访问。完整的 JRE 和 JDK 映像将包含[1]模块。
上述关键的内部 api 在当前 Java 平台中仍然可以访问。它们可以通过`jdk.unsupported`JDK 模块访问。完整的 JRE 和 JDK 映像将包含`jdk.unsupported`模块。
您可以使用 Java 依赖关系分析工具`jdeps`来帮助确定 Java 程序是否对 JDK 内部 API 有任何依赖关系。
您可以使用 Java 依赖性分析工具`jdeps`来帮助确定 Java 程序是否依赖于 JDK 内部 api。
这是一个有趣的变化。在未来的 Java 版本中，默认情况下，当前可访问的内部 api 可能无法访问。
......@@ -546,11 +546,11 @@ JEP-260 的实现使 Java 平台更加安全。JEP 的核心目标是封装大
7. 模块化运行时映像中有哪些目录？
8. 完整 JDK 映像中有哪些目录？
9. 编译时和运行时之间的可选阶段是什么？
10. Java 打包程序创建的二进制文件比以前的 Java 版本小的原因是什么？
10. Java Packager 创建的二进制文件比以前的 Java 版本小是什么原因？
# 进一步阅读
此处列出的参考资料将帮助您深入了解本章中介绍的概念：
* *学习 Java 9–模块化编程*，*可在*[获取 https://www.packtpub.com/application-development/learning-java-9-–-模块化编程视频](https://www.packtpub.com/application-development/learning-java-9-%E2%80%93-modular-programming-video)。**
*** *使用 Java 9 学习 JShell–一步一步*，在*[提供 https://www.packtpub.com/application-development/learn-jshell-java-9-step-step-video](https://www.packtpub.com/application-development/learn-jshell-java-9-step-step-video) .*****
\ No newline at end of file
* *学习 Java 9–模块化编程**可在*[获得 https://www.packtpub.com/application-development/learning-java-9-–-模块化编程视频](https://www.packtpub.com/application-development/learning-java-9-%E2%80%93-modular-programming-video)。**
*** *使用 Java 9 学习 JShell–逐步*，可在*[获得 https://www.packtpub.com/application-development/learn-jshell-java-9-step-step-video](https://www.packtpub.com/application-development/learn-jshell-java-9-step-step-video)。*****
\ No newline at end of file
new/master-java11/05.md
浏览文件 @ 51d73b2d
此差异已折叠。
new/master-java11/06.md
浏览文件 @ 51d73b2d
此差异已折叠。
new/master-java11/07.md
浏览文件 @ 51d73b2d
此差异已折叠。
new/master-java11/08.md
浏览文件 @ 51d73b2d
......@@ -2,7 +2,7 @@
在上一章中，我们深入回顾了垃圾收集，包括对象生命周期、垃圾收集算法、垃圾收集选项以及与垃圾收集相关的方法。我们简要介绍了 Java8 中垃圾收集的升级，重点介绍了新 Java 平台的变化。我们对 Java11 中的垃圾收集的探索包括：默认垃圾收集、折旧的垃圾收集组合、统一的垃圾收集日志记录以及持久存在的垃圾收集问题。
在本章中，我们将介绍如何使用**Java 微基准线束**（**JMH**）编写性能测试，这是一个用于编写 JVM 基准测试的 Java 线束库。我们将使用 Maven 和 JMH 来帮助说明使用新 Java 平台进行微标记的威力。
在本章中，我们将研究如何使用**Java 微基准线束**（**JMH**）编写性能测试，这是一个用于编写 JVM 基准测试的 Java 线束库。我们将使用 Maven 和 JMH 来帮助说明使用新 Java 平台进行微标记的威力。
具体来说，我们将讨论以下主题：
......@@ -13,11 +13,11 @@
# 技术要求
本章介绍 Java 11，Java 平台的**标准版**（**SE**）可以从 Oracle 官方下载网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html) ).
本章以 Java 11 为特色，Java 平台的**标准版**（**SE**）可从 Oracle 官方下载网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html)）。
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 的社区版可从网站（[下载 https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/) ).
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 的社区版可从网站（[下载 https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/)）。
本章的源代码可以在 GitHub 的 URL（[上找到 https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition](https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition) [).](https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition)
本章的源代码可以在 GitHub 的 URL（[上找到 https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition](https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition)[）。](https://github.com/PacktPublishing/Mastering-Java-11-Second-Edition)
# 微基准概述
......@@ -31,7 +31,7 @@ IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章
微基准过程阶段
在**设计**阶段，我们确定我们的目标，并据此设计我们的微基准；在**实现**阶段，我们编写微基准，然后在**执行**阶段，我们实际运行测试。在**分析**阶段，利用手中的微标记结果，对结果进行解释和分析。这导致了**增强**阶段的代码改进。一旦我们的代码被更新，我们就重新设计微基准测试，调整实现，或者直接进入**执行**阶段。这是一个循环过程，一直持续到我们实现了目标中确定的性能优化。
在**设计**阶段，我们确定了我们的目标并设计了相应的微基准；在**实现**阶段，我们编写了微基准，然后在**执行**阶段，我们实际运行了测试。在**分析**阶段，我们利用手中的微标记结果对结果进行了解释和分析。这导致了**增强**阶段的代码改进。一旦我们的代码被更新，我们就重新设计微基准测试，调整实现，或者直接进入**执行**阶段。这是一个循环的过程，一直持续到我们实现目标中确定的性能优化为止。
# 使用 JMH 的方法
......@@ -45,9 +45,9 @@ Maven，也称为 apachemaven，是一个项目管理和理解工具，我们可
# 安装 Java 和 Eclipse
您可以从 JDK 11 早期访问构建页面（[下载并安装 Java 11http://jdk.java.net/11/](http://jdk.java.net/11/) ).
您可以从 JDK 11 早期访问构建页面（[下载并安装 java11http://jdk.java.net/11/](http://jdk.java.net/11/)）。
一旦安装了 Java11，请下载最新版本的 Eclipse。在写这本书的时候，那是氧气。这是相关链接[https://www.eclipse.org/](https://www.eclipse.org/downloads/) [下载/](https://www.eclipse.org/downloads/)。
一旦安装了 Java11，请下载最新版本的 Eclipse。在写这本书的时候，那是氧气。这是相关链接[https://www.eclipse.org/](https://www.eclipse.org/downloads/)[下载/](https://www.eclipse.org/downloads/)。
# 动手实验
......@@ -57,7 +57,7 @@ Maven，也称为 apachemaven，是一个项目管理和理解工具，我们可
新 Maven 项目
接下来，我们需要添加一个依赖项。我们可以用下面的代码直接编辑`pom.xml`文件：
接下来，我们需要添加一个依赖项。我们可以用以下代码直接编辑`pom.xml`文件：
```
<dependency>
......@@ -103,7 +103,7 @@ JMH 测试结果
mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jmh -DarchetypeArtifactId=jmh-java-benchmark-archetype -DgroupId=com.packt -DartifactId=chapter8-benchmark -Dversion=1.0
```
一旦您输入`mvn`命令和前面的详细参数，您将看到通过终端向您报告的结果。根据您的使用级别，您可能会看到大量来自[的下载 https://repo.maven.apache.org/maven2/org/apache/maven/plugins/](https://repo.maven.apache.org/maven2/org/apache/maven/plugins/) 以及其他类似的存储库站点。
一旦您输入`mvn`命令和前面的详细参数，您将看到通过终端向您报告的结果。根据您的使用级别，您可能会看到大量来自[的下载 https://repo.maven.apache.org/maven2/org/apache/maven/plugins/](https://repo.maven.apache.org/maven2/org/apache/maven/plugins/)和其他类似的存储库站点。
您还将看到一个信息部分，通知您项目构建过程，如以下屏幕截图所示：
......@@ -111,7 +111,7 @@ mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jm
Maven 构建过程
可能会有其他插件和其他资源从[0]下载 https://repo.maven.apache.org 存储库。然后，您将看到一个信息反馈组件，它让您知道项目是以批处理模式生成的，如下所示：
可能会有额外的插件和从[下载的其他资源 https://repo.maven.apache.org](https://repo.maven.apache.org)仓库。然后，您将看到一个信息反馈组件，它让您知道项目是以批处理模式生成的，如下所示：
![](img/e52f236b-699b-4b52-96b1-8dc3ee5f32ac.png)
......@@ -123,13 +123,13 @@ Maven 项目生成
新 Maven 项目
将根据我们在`-DartifactId`选项中包含的参数创建一个文件夹，在我们的示例中，我们使用了`-DartifactId=chapter8-benchmark`，Maven 创建了一个`chapter8-benchmark`项目文件夹，如下所示：
我们将根据`-DartifactId`选项中包含的参数创建一个文件夹，在我们的示例中，我们使用了`-DartifactId=chapter8-benchmark`，Maven 创建了一个`chapter8-benchmark`项目文件夹，如下所示：
![](img/6fa5c2e2-0a15-4b74-b28d-cf902ca6a9d5.png)
基准项目文件夹
您将看到 Maven 创建了`pom.xml`文件以及一个源（`src`文件夹。在该文件夹中，在`C:\chapter8-benchmark\src\main\java\com\packt`的子目录结构下是`MyBenchmark.java`文件。Maven 为我们创建了一个基准类，如下图所示：
您将看到 Maven 创建了`pom.xml`文件以及一个源（`src`文件夹。在该文件夹中，`C:\chapter8-benchmark\src\main\java\com\packt`的子目录结构下是`MyBenchmark.java`文件。Maven 为我们创建了一个基准类，如下图所示：
![](img/cf163b03-6320-4908-8990-69ddf95f3598.png)
......@@ -194,7 +194,7 @@ public class MyBenchmark {
}
```
我们下一步是修改`testMethod()`，这样就有东西要测试了。下面是我们将用于基准测试的修改方法：
我们的下一步是修改`testMethod()`，这样就有东西要测试了。下面是我们将用于基准测试的修改方法：
```
@Benchmark
......@@ -209,7 +209,7 @@ System.out.println("Total: " + total);
编辑代码后，我们将导航回本例中的项目文件夹`C:\chapter8-benchmark`，并在命令提示符下执行`mvn clean install`。
您将看到几个存储库下载、源代码编译、插件安装，最后还有[0]指示符，如下所示：
您将看到多个存储库下载、源代码编译、插件安装，最后还有`Build Success`指示符，如下所示：
![](img/005eba3e-dc06-48c2-9443-1f89eeaec7ae.png)
......@@ -223,7 +223,7 @@ System.out.println("Total: " + total);
如果您导航到`\target`子文件夹，您将看到我们的`benchmarks.jar`文件已创建。这个 JAR 包含我们运行基准测试所需的内容。
`benchmarks.jar`中的外部依赖项在`pom.xml`文件中配置。
`benchmarks.jar`中的外部依赖在`pom.xml`文件中配置。
我们可以在 IDE 中更新我们的`MyBenchmark.java`文件，比如 Eclipse。然后，我们可以再次执行`mvn clean install`来覆盖我们的文件。在初始执行之后，我们的构建速度会更快，因为不需要下载任何东西。
......@@ -233,7 +233,7 @@ System.out.println("Total: " + total);
清洁安装过程
最后一步是从[0]文件夹运行基准工具。我们可以通过以下命令`-java -jar benchmarks.jar`来完成。即使对于简单代码上的小型基准测试（如我们的示例所示），运行基准测试也可能需要一些时间。可能会有几个迭代，包括热身，以提供更简洁有效的基准测试结果集
最后一步是从`C:\chapter8-benchmark\target`文件夹运行基准工具。我们可以通过以下命令`-java -jar benchmarks.jar`来完成。即使对于简单代码上的小型基准测试（如我们的示例所示），运行基准测试也可能需要一些时间。可能会有几个迭代，包括热身，以提供更简洁有效的基准测试结果集
这里提供了我们的基准测试结果。如您所见，测试运行了`00:08:08`个小时：
......@@ -250,7 +250,7 @@ System.out.println("Total: " + total);
# 模式
上一节中我们的基准测试结果的输出包括一个值为[1]的[0]列，它是吞吐量的缩写。这是默认模式，另外还有四种模式。所有 JMH 基准模式如下所示：
在上一节中，我们的基准测试结果的输出包括一个`Mode`列，该列的值为`thrpt`，是吞吐量的缩写。这是默认模式，另外还有四种模式。所有 JMH 基准模式如下所示：
| **模式** | **说明** |
| 全部 | 依次测量所有其他模式。 |
......@@ -259,7 +259,7 @@ System.out.println("Total: " + total);
| 单发时间 | 在这种模式下，没有 JVM 预热，测试是确定单个基准测试方法运行所需的时间。 |
| 吞吐量 | 这是默认模式，测量每秒的操作数。 |
要指定使用哪种基准模式，您需要将您的[0]代码行修改为以下内容之一：
要指定使用哪种基准模式，您需要将`@Benchmark`代码行修改为以下代码之一：
* `@Benchmark @BenchmarkMode(Mode.All)`
* `@Benchmark @BenchmarkMode(Mode.AverageTime)`
......@@ -279,7 +279,7 @@ System.out.println("Total: " + total);
* `HOURS`
* `DAYS`
为了进行此指定，我们只需在[0]行中添加以下代码：
为了进行此指定，我们只需在`@Benchmark`行中添加以下代码：
```
@Benchmark @BenchmarkMode(Mode.AverageTime)
......@@ -294,7 +294,7 @@ System.out.println("Total: " + total);
# 电源管理
有许多子系统可用于帮助您管理电源和性能之间的平衡（即[0]）。这些系统可以在基准测试期间改变时间状态。
有许多子系统可以用来帮助您管理电源和性能之间的平衡（即，`cpufreq`。这些系统可以在基准测试期间改变时间状态。
对于这个陷阱，有两种建议策略：
......@@ -338,7 +338,7 @@ if (value != null) {
问题是，为了消除死代码，有时可以删除基准测试代码。
常量折叠是编译时约束被实际结果替换时发生的编译器操作。编译器执行常量折叠以删除任何冗余的运行时计算。在下面的例子中，我们根据涉及第一个`int`的数学计算，得到了最后一个`int`，后面是第二个`int`：
常量折叠是编译时约束被实际结果替换时发生的编译器操作。编译器执行常量折叠以删除任何冗余的运行时计算。在下面的例子中，我们根据涉及第一个`int`的数学计算得到了最后一个`int`，后面是第二个`int`：
```
. . .
......@@ -373,7 +373,7 @@ int newValue = 3190;
有两种策略可以解决这个陷阱：
* 使用不同的问题集运行多个基准测试。在测试期间跟踪内存占用。
* 使用[0]注释来指定 JMH 状态。此注释用于定义实例的范围。有三种状态：
* 使用`@State`注释来指示 JMH 状态。此注释用于定义实例的范围。有三种状态：
* `Scope.Benchmark`：实例在运行同一测试的所有线程之间共享
* `Scope.Group`：每个线程组分配一个实例
* `Scope.Thread`：每个线程都有自己的实例。这是默认状态
......@@ -401,5 +401,5 @@ int newValue = 3190;
下面列出的参考资料将帮助您深入了解本章介绍的概念：
* *Java EE 开发与 Eclipse*，可在[上获得 https://www.packtpub.com/application-development/java-ee-development-eclipse](https://www.packtpub.com/application-development/java-ee-development-eclipse) .
* *Java EE Eclipse 开发-第二版*，点击[https://www.packtpub.com/application-development/java-ee-development-eclipse-second-edition](https://www.packtpub.com/application-development/java-ee-development-eclipse-second-edition) .
\ No newline at end of file
* *Java EE 开发与 Eclipse*，可在[上获得 https://www.packtpub.com/application-development/java-ee-development-eclipse](https://www.packtpub.com/application-development/java-ee-development-eclipse)。
* *Java EE Eclipse 开发-第二版*，可在[上获得 https://www.packtpub.com/application-development/java-ee-development-eclipse-second-edition](https://www.packtpub.com/application-development/java-ee-development-eclipse-second-edition)。
\ No newline at end of file
new/master-java11/09.md
浏览文件 @ 51d73b2d
此差异已折叠。
new/master-java11/10.md
浏览文件 @ 51d73b2d
此差异已折叠。
new/master-java11/11.md
浏览文件 @ 51d73b2d
此差异已折叠。
new/master-java11/12.md
浏览文件 @ 51d73b2d
......@@ -13,9 +13,9 @@
# 技术要求
本章以及随后的几章介绍 Java11。Java 平台的 SE 可从 Oracle 官方网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html) ).
本章以及随后的几章介绍 Java11。Java 平台的 SE 可从 Oracle 官方网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html)）。
集成开发环境（IDE）软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 的社区版可从网站（[下载 https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/) ).
集成开发环境（IDE）软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 的社区版可从网站（[下载 https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/)）。
# 反应式程序设计
......@@ -29,9 +29,9 @@
有更多的反应式编程。首先，让我们考虑一下数据流是由发布者以异步方式提供给订阅服务器的。
数据流是字符串和基本数据类型的二进制输入/输出，`DataInput`接口用于输入流，`DataOutput `接口用于输出流。
数据流是字符串和原始数据类型的二进制输入/输出，`DataInput`接口用于输入流，`DataOutput `接口用于输出流。
处理器或处理器链可用于转换数据流，而无需发布者或订阅者参与。在下面的示例中，**处理器**在数据流上工作，没有**发布者**或**订户**的参与，甚至没有意识到：
处理器或处理器链可用于转换数据流，而无需发布者或订阅者参与。在下面的例子中，**处理器**在没有**发布者**或**订户**参与，甚至没有意识到的情况下处理数据流：
![](img/ddece52b-6927-498a-9017-31a81864923d.png)
......@@ -74,22 +74,22 @@ reactivestreams 计划旨在解决控制线程之间如何交换数据流的问
| 没有 | NOP 执行是可以重复调用而不影响调用线程的执行。 |
| 响应度 | 这个术语是指组件的响应能力。 |
| 正常返回 | 正常返回是指当没有错误时的正常状态。`onError`方法是标准允许的唯一通知用户故障的方法。 |
| 信号 | 方法之一：
| 信号 | 以下方法之一：
* `cancel()`
* `onComplete()`
* `onError()`
* `onNext()`
* `onSubscribe()`
* `request()`
|
在下一节中，我们将研究 Java 平台中的`Flow`API，因为它们对应于反应流规范。
在下一节中，我们将研究 Java 平台中的`Flow`api，因为它们对应于反应流规范。
# 流 API
[0]类是[1]包的一部分。它帮助开发人员将反应式编程融入到他们的应用程序中。这个类有一个方法`defaultBufferSize()`和四个接口。
`Flow`类是`java.util.concurrent`包的一部分。它帮助开发人员将反应式编程融入到他们的应用程序中。这个类有一个方法`defaultBufferSize()`和四个接口。
`defaultBufferSize()`方法是一个静态方法，返回发布和订阅缓冲区的默认缓冲区大小。默认为`256`，返回为`int`。
......@@ -104,7 +104,7 @@ reactivestreams 计划旨在解决控制线程之间如何交换数据流的问
public static interface Flow.Publisher<T>
```
此函数接口可以用作 Lambda 表达式赋值目标。它只接受订阅项类型`<T>`的一个参数。它有一种方法，即`void subscribe(Flow.Subscriber subscriber)`。
此函数接口可以用作 Lambda 表达式赋值目标。它只接受一个参数 subscribed item type`<T>`。它有一种方法，即`void subscribe(Flow.Subscriber subscriber)`。
# 这个流量订户接口
......@@ -114,7 +114,7 @@ public static interface Flow.Publisher<T>
public static interface Flow.Subscriber<T>
```
此接口设置为接收消息。它只接受一个参数，即订阅项类型`<T>`。它有以下方法：
此接口设置为接收消息。它只接受一个参数 subscribed item type，`<T>`。它有以下方法：
* `void onComplete()`
* `void onError(Throwable throwable)`
......@@ -123,7 +123,7 @@ public static interface Flow.Subscriber<T>
# 这个流量订阅接口
[0]接口确保只有订户接收请求。此外，您将在此处看到，订阅可以随时取消：
`Flow.Subscription`接口确保只有订户接收请求。此外，您将在此处看到，订阅可以随时取消：
```
public static interface Flow.Subscription
......@@ -136,7 +136,7 @@ public static interface Flow.Subscription
# 这个流量处理机接口
`Flow.Processor`接口可以兼作`Subscriber`和`Publisher`。此处提供了实现：
`Flow.Processor`接口可以同时作为`Subscriber`和`Publisher`。此处提供了实现：
```
static interface Flow.Processor<T,R> extends Flow.Subscriber<T>, Flow.Publisher<R>
......@@ -148,7 +148,7 @@ static interface Flow.Processor<T,R> extends Flow.Subscriber<T>, Flow.Publisher<
void subscribe(Flow.Subscriber<? super T> subscriber)
```
`Flow.Processor`还从`java.util.concurrent.Flow.Subscriber`接口继承了以下方法：
`Flow.Processor`还继承了`java.util.concurrent.Flow.Subscriber`接口的以下方法：
* `void onComplete()`
* `void onError(Throwable throwable)`
......@@ -191,7 +191,7 @@ public class packtSubscriber<T> implements Subscriber<T> {
}
```
如您所见，实现`Subscriber`并不困难。繁重的工作是由介于`Subscriber`和`Publisher`之间的处理器完成的。让我们看一个示例实现，`Publisher`将数据流发布给订阅服务器：
如您所见，实施`Subscriber`并不困难。繁重的工作由位于`Subscriber`和`Publisher`之间的处理器完成。让我们看一个示例实现，`Publisher`向订阅者发布数据流：
```
import java.util.concurrent.SubsmissionPublisher;
......@@ -249,9 +249,9 @@ Java 平台最近得到了增强，以改进并发性的使用。在本节中，
# Java 线程
Java 中的线程是一个程序执行，内置在 JVM 中。`Thread`类是`java.lang`包（`java.lang.Thread`的一部分。线程具有控制 JVM 执行它们的顺序的优先级。虽然概念很简单，但实现却不简单。我们先来仔细看看`Thread`课。
Java 中的线程是一个程序执行，内置在 JVM 中。`Thread`类是`java.lang`包（`java.lang.Thread`的一部分。线程具有控制 JVM 执行它们的顺序的优先级。虽然概念很简单，但实现却不简单。让我们先来仔细看看`Thread`课程。
[0]类有一个嵌套类：
`Thread`类有一个嵌套类：
* `public static enum Thread.State`
......@@ -265,7 +265,7 @@ Java 中的线程是一个程序执行，内置在 JVM 中。`Thread`类是`java
* `public static final int MIN_PRIORITY`
* `public static final int NORM_PRIORITY`
[0]类有八个构造函数，它们都分配了一个新的[1]对象。以下是构造函数签名：
`Thread`类有八个构造函数，它们都分配一个新的`Thread`对象。以下是构造函数签名：
* `public Thread()`
* `public Thread(Runnable target)`
......@@ -276,7 +276,7 @@ Java 中的线程是一个程序执行，内置在 JVM 中。`Thread`类是`java
* `public Thread(ThreadGroup group, Runnable target, String name, long stackSize)`
* `public Thread(ThreadGroup group, String name)`
[0]类还有 43 个方法，其中 6 个已被弃用。剩下的方法在这里列出，除了分别列出的访问器和变异器。有关每种方法的详细信息，请参阅文档：
`Thread`类还有 43 个方法，其中 6 个已经被弃用。剩下的方法在这里列出，除了分别列出的访问器和变异器。有关每种方法的详细信息，请参阅文档：
* `public static int activeCount()`
* `public final void checkAccess()`
......@@ -304,7 +304,7 @@ Java 中的线程是一个程序执行，内置在 JVM 中。`Thread`类是`java
* `public String toString()`
* `public static void yield()`
以下是[0]类的访问器/获取器和变异器/设置器列表：
以下是`Thread`类的访问器/获取器和变异器/设置器列表：
* 访问器/获取器：
* `public static Map<Thread, StackTraceElement[]> getAllStacktraces()`
......@@ -334,7 +334,7 @@ public synchronized void protectedMethod() {
}
```
下面的代码片段演示如何使用[0]关键字锁定方法中的代码块：
下面的代码片段演示了如何使用`synchronized`关键字锁定方法中的代码块：
```
. . .
......@@ -398,19 +398,19 @@ varT.start();
# 可完成的未来 API 增强
[0]类是[1]包的一部分。这个类扩展了`Object`类，实现了`Future<T>`和`CompletionStage<T>`接口。此类用于注释可以完成的线程。我们可以使用`CompletableFuture`类来表示未来的结果。当使用 complete 方法时，可以完成将来的结果。
`CompletableFuture<T>`类是`java.util.concurrent`包的一部分。该类扩展了`Object`类，实现了`Future<T>`和`CompletionStage<T>`接口。此类用于注释可以完成的线程。我们可以使用`CompletableFuture`类来表示未来的结果。当使用 complete 方法时，可以完成将来的结果。
重要的是要认识到，如果多个线程试图同时完成（finish 或 cancel），除一个线程外，其他所有线程都将失败。让我们看看这个类，然后看看增强功能。
# 课程详情
[0]类有一个标记异步任务的嵌套类：
`CompletableFuture<T>`类有一个嵌套类，用于标记异步任务：
```
public static interface CompletableFuture.AsynchronousCompletionTask
```
[0]类的构造函数必须与提供的构造函数签名同步。它也不能接受任何论据。该类具有以下方法，这些方法按返回的内容组织：
`CompletableFuture<T>`类的构造函数必须与提供的构造函数签名同步。它也不能接受任何论据。该类具有以下方法，这些方法按返回的内容组织：
返回`CompletionStage`：
......@@ -510,11 +510,11 @@ public static interface CompletableFuture.AsynchronousCompletionTask
作为当前 Java 平台的一部分，`CompletableFuture<T>`类收到了以下增强：
* 添加了基于时间的增强功能：
* 这使得基于失效时间的完成
* 这样可以根据经过的时间完成
* 现在也支持延迟执行
* 子类显著增强：
* 扩展`CompletableFuture`更容易
* 延伸`CompletableFuture`更容易
* 子类支持可选的默认执行器
具体来说，Java 9 中添加了以下方法：
......@@ -542,7 +542,7 @@ public static interface CompletableFuture.AsynchronousCompletionTask
* CPU 功耗将降低
* 硬件线程将执行得更快
此提示功能将作为`java.lang.Thread`类的一部分包含在新的`onSpinWait()`方法中。下面是实现`onSpinWait()`方法的一个例子：
这个提示功能将包含在一个新的`onSpinWait()`方法中，作为`java.lang.Thread`类的一部分。下面是实现`onSpinWait()`方法的示例：
```
. . .
......@@ -567,7 +567,7 @@ while ( notInReceiptOfEventNotification ); {
2. 什么是数据流？
3. 使用反应式编程的主要好处是什么？
4. 反应式编程的无影响授权有哪些规定？
5. `Flow`a 类是什么套餐？
5. `Flow`a 类是什么包装？
6. 列出`Flow`类的四个接口。
7. 什么是并发性？
8. 并发和并行的区别是什么？
......@@ -578,5 +578,5 @@ while ( notInReceiptOfEventNotification ); {
以下是您可以参考的信息列表：
* *Java 9*的反应式编程，可在[上找到 https://www.packtpub.com/application-development/reactive-programming-java-9](https://www.packtpub.com/application-development/reactive-programming-java-9) .
* *Java 9 并发高级元素【视频】*，在[提供 https://www.packtpub.com/application-development/java-9-concurrency-advanced-elements-video](https://www.packtpub.com/application-development/java-9-concurrency-advanced-elements-video) .
\ No newline at end of file
* *Java 9*反应式编程[提供 https://www.packtpub.com/application-development/reactive-programming-java-9](https://www.packtpub.com/application-development/reactive-programming-java-9)。
* *Java 9 并发高级元素【视频】*[提供 https://www.packtpub.com/application-development/java-9-concurrency-advanced-elements-video](https://www.packtpub.com/application-development/java-9-concurrency-advanced-elements-video)。
\ No newline at end of file
new/master-java11/13.md
浏览文件 @ 51d73b2d
此差异已折叠。
new/master-java11/14.md
浏览文件 @ 51d73b2d
......@@ -15,9 +15,9 @@
# 技术要求
本章及后续章节主要介绍 Java 11，Java 平台的**标准版**（**SE**）可从 Oracle 官方网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html) ).
本章及后续章节主要介绍 Java 11，Java 平台的**标准版**（**SE**）可从 Oracle 官方网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html)）。
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 的社区版可从网站（[下载 https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/) ).
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 的社区版可从网站（[下载 https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/)）。
# 统一 JVM 日志记录
......@@ -41,7 +41,7 @@ Java9 中引入了为 JVM 创建统一的日志模式。以下是这项工作的
* 设置所有日志消息的格式，使其易于人阅读
* 添加装饰，如正常运行时间、级别和标记
* 与级别类似，用于选择基于装饰记录哪些消息
* 将 Java 9[0]之前的日志转换为使用统一日志作为输出
* 将 pre-java9`tty>print`日志转换为使用统一日志作为输出
* 允许使用`jcmd`和`MBeans`进行动态消息配置
* 允许启用和禁用单个日志消息
* 添加确定装饰打印顺序的功能
......@@ -110,7 +110,7 @@ filesize=<file size in kb>
parameter=value
```
下面的`-Xlog`示例后面是一个描述：
以下`-Xlog`示例后面是说明：
```
-Xlog:all
......@@ -119,10 +119,10 @@ parameter=value
在前面的示例中，我们告诉 JVM 执行以下操作：
* 记录所有消息
* 使用`info`关卡
* 使用`info`水准仪
* 向`stdout`提供输出
通过这个例子，所有`warning`消息仍将输出到`stderr`。
在本例中，所有的`warning`消息仍将输出到`stderr`。
以下示例在`debug`级别记录消息：
......@@ -132,8 +132,8 @@ parameter=value
在前面的示例中，我们告诉 JVM 执行以下操作：
* 记录至少带有[0]和[1]标记的所有消息
* 使用`debug`关卡
* 记录至少带有`gc`和`rt`标记的所有消息
* 使用`debug`水准仪
* 向`stdout`提供输出
以下示例将输出推送到外部文件：
......@@ -144,8 +144,8 @@ parameter=value
在前面的示例中，我们告诉 JVM 执行以下操作：
* 禁用除标记有[0]个标记的邮件以外的所有邮件
* 使用`debug`关卡
* 禁用除标记有`rt`标记的消息以外的所有消息
* 使用`debug`水准仪
* 向名为`rtdebug.txt`的文件提供输出
# 装饰品
......@@ -161,7 +161,7 @@ parameter=value
* `timenanos`：当前时间（纳秒）
* `uptime`：JVM 启动后的时间，以秒和毫秒为单位
* `uptimemillis`：JVM 启动后的时间，以毫秒为单位
* `uptimenanos`：JVM 启动后的时间，单位为纳秒
* `uptimenanos`：JVM 启动后的时间，以纳秒为单位
装饰可以超越或包含在统一的日志输出中。无论使用哪种装饰，它们都将按以下顺序出现在输出中：
......@@ -186,7 +186,7 @@ parameter=value
# 使用 Xlog 输出
Java 日志框架支持三种类型的输出，包括直接使用[0]命令行语法的示例：
Java 日志框架支持三种类型的输出，包括直接使用`-Xlog`命令行语法的示例：
在下面的示例中，我们向`stderr`提供输出：
......@@ -208,7 +208,7 @@ Java 日志框架支持三种类型的输出，包括直接使用[0]命令行语
# 标签
新的日志框架由一组在 JVM 中标识的标记组成。如果需要，可以在源代码中更改这些标记。标签应该是自识别的，比如垃圾回收的[0]。
新的日志框架由一组在 JVM 中标识的标记组成。如果需要，可以在源代码中更改这些标记。标签应该是自识别的，例如用于垃圾收集的`gc`。
当多个标记组合在一起时，它们形成一个标记集。当我们通过源代码添加自己的标记时，每个标记都应该与一个标记集相关联。这将有助于确保标签保持有序，并且易于人类阅读。
......@@ -220,13 +220,13 @@ Java 日志框架支持三种类型的输出，包括直接使用[0]命令行语
# 编译模式
现代 Java 平台的变化包括对[0]C1[1]和[2]C2[3]JVM 编译器的粒度控制。如下图所示，Java HotSpot JVM 有两种 JIT 编译模式**C1**和**C2**：
现代 Java 平台的变化包括对 JVM 编译器的细粒度控制。如下图所示，Java HotSpot JVM 有两种 JIT 编译模式**C1**和**C2**：
![](img/99ad8a9a-c4a9-4cdb-8e8f-9f33a0a5c847.png)
Java 热点 JVM 编译模式
**C1**和**C2**编译模式使用不同的编译技术，如果在同一个代码基上使用，可以生成不同的机器代码集。
**C1**和**C2**编译模式使用不同的编译技术，如果在同一个代码基上使用，可以产生不同的机器代码集。
# C1 编译模式
......@@ -245,7 +245,7 @@ Java HotSpot VM 中的 C1 编译模式通常用于具有以下特征的应用程
# 分层编译
分层编译允许我们同时使用**C1**和**C2**两种编译模式。从 Java8 开始，分层编译是默认的过程。如图所示，启动时使用**C1**模式有助于提供更大的优化。然后，一旦 app 充分预热，则采用**C2**模式：
分层编译允许我们同时使用**C1**和**C2**编译模式。从 Java8 开始，分层编译是默认的过程。如图所示，启动时使用**C1**模式有助于提供更大的优化。然后，一旦 app 充分预热，则采用**C2**模式：
![](img/b754514c-8f92-4362-a596-a2aae85512c2.png)
......@@ -261,15 +261,15 @@ Java 承诺能够有限地控制 JVM 编译器并在运行时进行更改。这
编译器指令结构
数据交换采用**JavaScript 对象表示法**（**JSON**格式）。指令文件与 JSON 有以下格式差异：
**JavaScript 对象表示法**（**JSON**格式）用于数据交换。指令文件与 JSON 有以下格式差异：
* `int`和`doubles`是唯一支持的数字格式
* 双正斜杠（[0]）可用于注释行
* 尾随逗号（`,`可用于数组和对象
* 双正斜杠（`//`）可用于注释行
* 尾随逗号（`,`可用于数组和对象中
* 不支持转义字符
* 选项名的格式为字符串，不必加引号
您可以在[了解更多关于 JSON 的信息 http://www.json.org](http://www.json.org) .
您可以在[了解更多关于 JSON 的信息 http://www.json.org](http://www.json.org)。
我们可以在命令行中使用以下语法添加指令文件：
......@@ -277,7 +277,7 @@ Java 承诺能够有限地控制 JVM 编译器并在运行时进行更改。这
-XX:CompilerDirectivesFile=<file>
```
下面是指令文件的 shell 示例：
以下是指令文件的 shell 示例：
```
[ // Open square bracket marks the start of the directives file
......@@ -314,9 +314,9 @@ Java 承诺能够有限地控制 JVM 编译器并在运行时进行更改。这
在现代 Java 平台中添加了七个新的诊断命令，以增强诊断 JDK 和 JVM 的能力。
[0]命令打印当前排队等待编译的方法。由于 C1 和 C2 编译模式位于不同的队列上，因此需要向特定队列发出此命令。
`print_codegenlist`命令打印当前排队等待编译的方法。由于 C1 和 C2 编译模式位于不同的队列上，因此需要向特定队列发出此命令。
`dump_codelist`诊断命令将打印所编译方法的下列信息：
`dump_codelist`诊断命令将打印编译方法的下列信息：
* 完整签名
* 地址范围
......@@ -327,7 +327,7 @@ Java 承诺能够有限地控制 JVM 编译器并在运行时进行更改。这
此外，`dump_codelist`诊断命令允许将输出定向到`stdout`或指定的文件。输出可以是 XML 格式或标准文本。
[0]命令允许我们打印以下内容：
`print_codeblocks`命令允许我们打印以下内容：
* 代码缓存大小
* 代码缓存列表
......@@ -336,18 +336,18 @@ Java 承诺能够有限地控制 JVM 编译器并在运行时进行更改。这
`datadump_request`诊断命令向**Java 虚拟机床接口**（**JVMTI**发送转储请求。它取代了**Java 虚拟机调试接口**（**JVMDI**）和**Java 虚拟机评测接口**（**JVMPI**）。
通过`set_vmflag`命令，我们可以在 JVM 或库中设置命令行标志或选项。
使用`set_vmflag`命令，我们可以在 JVM 或库中设置命令行标志或选项。
[0]diagnostic 命令打印所有加载类的列表及其继承结构。
`print_class_summary`诊断命令打印所有加载类的列表及其继承结构。
[0]命令打印所有 UTF-8 字符串常量。
`print_utf8pool`命令打印所有 UTF-8 字符串常量。
# 堆分析代理
jvmti[0]代理最近从 Java 平台上删除。以下是与此更改相关的关键术语：
jvmti`hprof`代理最近从 Java 平台上删除了。以下是与此更改相关的关键术语：
* **工具接口**（**TI**）：这是一个本机编程接口，允许工具控制 Java 虚拟机中正在运行的应用程序的执行。该接口还允许状态查询。这个工具的完整术语是 Java 虚拟机工具接口，或 jvmti。
* **堆分析**（**HPROF**）：这是一个内部 JDK 工具，用于分析 JVM 对 CPU 和堆的使用。开发人员对[0]最常见的暴露是崩溃后生成的文件。生成的文件包含堆转储。
* **工具接口**（**TI**）：这是一个本机编程接口，允许工具控制正在 Java 虚拟机内运行的应用程序的执行。该接口还允许状态查询。这个工具的完整术语是 Java 虚拟机工具接口，或 jvmti。
* **Heap Profiling**（**HPROF**）：这是一个内部 JDK 工具，用于分析 JVM 对 cpu 和堆的使用。开发人员最常见的暴露是崩溃后生成的文件。生成的文件包含堆转储。
Java11JDK 不包含`hprof`代理。它被删除主要是因为有更好的替代品可用。以下是它们的相关功能表：
......@@ -387,7 +387,7 @@ jhat
下面简要介绍与 JHAT 命令相关的选项：
| **选项** | **说明** | **违约** |
| `-J<flag>` | 这会将[0]传递给运行时系统 | 不适用 |
| `-J<flag>` | 这会将`<flag>`传递给运行时系统 | 不适用 |
| `-stack<bool>` | 这将切换对象分配调用堆栈的跟踪 | `true` |
| `-refs<bool>` | 这将切换对对象引用的跟踪 | `true` |
| `-port<port>` | 这表示 JHAT HTTP 服务器的端口 | `7000` |
......@@ -422,7 +422,7 @@ exampleFlag UnguardOnExecutionViolation = 4 is outside the allowed range [0 . .
以下是一些有关 Java 平台更改的细节：
* 展开当前的`globals.hpp`源文件，以确保完整的标志默认值和允许的范围被记录
* 定义一个框架，以支持将来添加新的 JVM 命令行标志：
* 定义一个框架以支持将来添加新的 JVM 命令行标志：
* 这将包括值范围和值集
* 这将确保有效性检查将应用于所有新添加的命令行标志
......@@ -434,15 +434,15 @@ exampleFlag UnguardOnExecutionViolation = 4 is outside the allowed range [0 . .
# 为旧平台版本编译
Java 编译器`javac`在 Java 9 中进行了更新，以确保可以使用它来编译 Java 程序，以便在用户选择的旧版本 Java 平台上运行。在下面的截图中可以看到，`javac`有几个选项，包括`-source`和`-target`。以下截图中的`javac`来自 Java 8：
Java 编译器`javac`在 Java9 中进行了更新，以确保它可以用来编译 Java 程序，以便在用户选择的旧版本 Java 平台上运行。在下面的截图中可以看到，`javac`有几个选项，包括`-source`和`-target`。以下截图中显示的`javac`来自 Java 8：
![](img/f4dc0735-e351-4d4d-aa78-0197bb1de867.png)
Java8 中的 javac 选项
[0]选项用于指定编译器接受的 Java 版本。`-target`选项通知您`javac`将生成哪个版本的类文件。默认情况下，`javac`生成最新 Java 版本和平台 API 版本的类文件。当编译的应用程序使用仅在最新平台版本中可用的 API 时，这可能会导致问题。这将导致应用程序无法在较旧的平台版本上运行，尽管使用了`-source`和`-target`选项。
`-source`选项用于指定编译器接受的 Java 版本。`-target`选项通知您将生成哪个版本的类文件`javac`。默认情况下，`javac`生成最新 Java 版本和平台 api 版本的类文件。当编译的应用程序使用仅在最新平台版本中可用的 API 时，这可能会导致问题。这将导致应用程序无法在较旧的平台版本上运行，尽管使用了`-source`和`-target`选项。
为了解决上述问题，Java 中提供了一个新的命令行选项，这个选项是`--release`选项，使用时会自动配置`javac`，生成链接到特定平台版本的类文件。下面的屏幕截图显示了当前 Java 平台的`javac`选项。如您所见，新的`--release`选项包括：
为了解决上述问题，Java 中提供了一个新的命令行选项，这个选项是`--release`选项，当使用这个选项时，会自动配置`javac`来生成与特定平台版本相链接的类文件。下面的屏幕截图显示了当前 Java 平台的`javac`选项。如您所见，新的`--release`选项包括：
![](img/69faeaf0-a366-4c5f-809d-1ae6a3b244fe.png)
......@@ -456,7 +456,7 @@ javac --release <release> <source files>
# 基于 Java 的 JIT 编译器实验
Java 10 启用了基于 Java 的**即时**（**JIT**编译器，可作为 Linux/x64 平台的 JIT 实验编译器。基于 Java 的 JIT 编译器称为 GRAL
在 java10 中启用了基于 Java 的准时制（Just-in-Time）编译器（**JIT**），可以作为 Linux/x64 平台的实验性 JIT 编译器。基于 Java 的 JIT 编译器被称为 Graal
做出这一更改的目的是希望通过实验可以证明将 JIT 编译器添加到 JDK 中的概念
......@@ -468,7 +468,7 @@ Java 10 启用了基于 Java 的**即时**（**JIT**编译器，可作为 Linux/
# 问题
1. Java9 中引入了什么模式来处理 JVM 日志记录？
1. Java9 中引入的 JVM 日志记录模式是什么？
2. 日志记录的五个类别是什么？
3. 什么是装饰品？
4. 日志中的详细程度是多少？
......@@ -484,4 +484,4 @@ Java 10 启用了基于 Java 的**即时**（**JIT**编译器，可作为 Linux/
以下是您可以参考的信息列表：
* *干净代码 Java SE 9 入门【视频】*，可在[获取 https://www.packtpub.com/application-development/getting-started-clean-code-java-se-9-video](https://www.packtpub.com/application-development/getting-started-clean-code-java-se-9-video) .
\ No newline at end of file
* *干净代码 Java SE 9 入门【视频】*[提供 https://www.packtpub.com/application-development/getting-started-clean-code-java-se-9-video](https://www.packtpub.com/application-development/getting-started-clean-code-java-se-9-video)。
\ No newline at end of file
new/master-java11/15.md
浏览文件 @ 51d73b2d
此差异已折叠。
new/master-java11/16.md
浏览文件 @ 51d73b2d
......@@ -2,7 +2,7 @@
在最后一章中，我们重点介绍了 Java 平台提供的一些激动人心的实用程序的最佳实践。具体来说，我们介绍了 UTF-8 属性文件、Unicode、Linux/AArch64 端口、多分辨率图像和公共区域设置数据存储库。
本章概述了 Java 平台的未来开发，该平台超越 Java11。我们将研究 Java19.3（12）和 19.9（13）的计划以及我们将来可能看到的进一步变化。我们将首先简要概述 JEP。
本章概述了 Java 平台在 Java11 之外的未来发展。我们将看看 Java19.3（12）和 19.9（13）的计划以及将来可能看到的进一步变化。我们将从一个简短的 JEP 概述开始。
具体而言，本章包括以下内容：
......@@ -14,13 +14,13 @@
# 技术要求
本章及后续章节主要介绍 Java 11，Java 平台的**标准版**（**SE**）可从 Oracle 官方下载网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html) ).
本章及后续章节主要介绍 Java 11。Java 平台的**标准版**（**SE**）可从 Oracle 官方下载网站（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html)）。
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 社区版可从网站（[下载 https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/) ).
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章和后续章节相关的所有编码。IntelliJ IDEA 的社区版可从网站（[下载 https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/)）。
# JDK 增强方案概述
**JDK 增强建议**（**JEP**）包含一个建议对 JDK 进行更改的列表。这个公开的列表用于通知开发人员并为 Java 平台提供一个长期计划
**JDK 增强建议**（**JEP**）由 JDK 的建议变更列表组成。这个公开的列表用于通知开发人员并为 Java 平台提供一个长期计划
JEP 的核心是增强功能本身。增强的标准包括：
......@@ -33,14 +33,14 @@ JEP 的核心是增强功能本身。增强的标准包括：
JEP 具有以下顺序状态：
1. **草案**：这是最早的状态，在 JEP 已经写好，作者正在传阅征求意见时使用
2. **发布**：作者达成共识后，即可登录 JEP 档案
3. **提交**：一旦 JEP 被认为可以进行正式评估，作者就设置此状态
1. **草案**：这是最早的状态，当 JEP 已经写好，作者正在传阅征求共识时使用
2. **发布**：一旦作者达成共识，JEP 即可登录 JEP 档案
3. **提交**：一旦 JEP 被认为准备好进行正式评估，作者即设置此状态
4. **候选**：一旦 OpenJDK 负责人接受了 JEP，就变为这个状态
5. **资金**资金：资金表示功能区领导或集团领导判断 JEP 资金充足
5. **资助**：资助是指某个职能部门领导或某个小组领导判断 JEP 资金充足
6. **已完成**：此状态表示增强工作已完成并在版本发布中交付
不是每个 JEP 都能通过整个六个阶段的工作流程。其他状态包括**活动**、**拒绝**、**撤回**。
并不是每个 JEP 都能完成整个六阶段的工作流程。其他状态包括**激活**、**拒绝**、**撤销**。
Java 平台的每一个潜在更改都将被描述为有针对性的、提交的或起草的。有针对性是指已指定用于未来 Java 版本的更改，已提交是指已提交但未针对 Java 平台特定版本的更改，并且起草的更改仍在绘图板上，尚未准备好提交或指定为有针对性的更改。
......@@ -92,7 +92,7 @@ JVM 依赖于一个常量池来确定类布局、实例、接口和数组。每
* GTK3 将在布局方面进行现代化改造
* 将为 JMX 创建新的 restapi
有关这些建议的详细信息，请访问[http://openjdk.java.net/jeps/0。](http://openjdk.java.net/jeps/0)
每项建议的详细信息可从[获得 http://openjdk.java.net/jeps/0。](http://openjdk.java.net/jeps/0)
# JEP 起草
......@@ -106,7 +106,7 @@ JVM 依赖于一个常量池来确定类布局、实例、接口和数组。每
* 高效数组比较
* 启用在 GPU 上执行 Java 方法
* 使用值类型增强的`ManderblotSet`演示
* 增强伪随机数发生器
* 增强型伪随机数发生器
* 改进的 IPv6 支持
* 孤立的方法
* Java 线程消毒剂
......@@ -114,13 +114,13 @@ JVM 依赖于一个常量池来确定类布局、实例、接口和数组。每
* 密钥派生 API
* 包装工具
* 在 JVM 编译的方法上提供稳定的 USDT 探测点
* 支持`ByteBuffer`映射到非易失性存储器上
* 支持映射到非易失性存储器上的`ByteBuffer`
* 及时减少未使用的提交内存
* JVM 中的类型运算符表达式
* 方法句柄的未装箱参数列表
* 使用 UTF-8 作为默认字符集
有关这些建议的详细信息，请访问[http://openjdk.java.net/jeps/0。](http://openjdk.java.net/jeps/0)
每项建议的详细信息可从[获得 http://openjdk.java.net/jeps/0。](http://openjdk.java.net/jeps/0)
# 正在进行的特别项目
......@@ -191,14 +191,14 @@ Caciocavallo 项目旨在改进 OpenJDK AWT 内部接口。这扩展到二维子
# 编译器语法
编译器语法项目正在开发一个基于 ANTLR 语法的实验性 Java 编译器。**ANTLR**（简称**另一种语言识别工具**），是一种解析器，用于读取、处理和执行结构化文本或二进制文件。项目组希望这个 Java 编译器能够取代当前的编译器，因为它使用的是手写解析器**LALR**（缩写为**Look Ahead Left to Right**）。LALR 解析器已经被项目组确认为脆弱的，难以扩展。
编译器语法项目正在开发一个基于 ANTLR 语法的实验性 Java 编译器。**ANTLR**（简称**另一种语言识别工具**），是一种读取、处理和执行结构化文本或二进制文件的解析器。项目组希望这个 Java 编译器能够取代当前的编译器，因为它使用的是手写解析器**LALR**（缩写为**Look Ahead Left to Right**）。LALR 解析器已经被项目组确认为脆弱的，难以扩展。
# 设备 I/O
这个项目打算通过 Java 级 API 提供对通用外围设备的访问。项目组希望支持的外围设备的初始列表包括：
* **GPIO**（简称**通用输入/输出**）
* **I2C**（简称**集成电路总线**）
* **I2C**（简称**集成电路间总线**）
* **SPI**（简称**串口**）
* **UART**（简称**通用异步收发机**）
......@@ -212,7 +212,7 @@ HarfBuzz 集成项目希望将 HarfBuzz 布局引擎集成到 Java 开发工具
# 科纳
Kona 项目正在定义和实现 Java API，以支持**物联网**（**物联网**领域。这包括网络技术和协议。尽管没有说明，但安全和安保对于这项工作的成功实施至关重要。
Kona 项目正在定义和实现 javaapi，以支持**物联网**（**物联网**领域。这包括网络技术和协议。尽管没有说明，但安全和安保对于这项工作的成功实施至关重要。
# 开放 JFX
......
new/master-java11/17.md
浏览文件 @ 51d73b2d
......@@ -2,7 +2,7 @@
在最后一章中，我们展望了 Java 平台在 Java11 之外的未来发展。我们查看了 Java19.3 和 19.9 的计划，以及将来可能会看到的进一步变化。我们首先简要概述了 JEP，并涵盖了现有的 JEP 和正在进行的特别项目。
Java 平台未来的关键是 Java 社区。这是本章的重点。我们将讨论 Java 社区以及开发人员如何为 Java 平台做出贡献。具体而言，我们将介绍以下与 Java 社区相关的主题：
Java 平台未来的关键是 Java 社区。这是本章的重点。我们将讨论 Java 社区以及开发人员如何为 Java 平台做出贡献。具体来说，我们将介绍以下与 Java 社区相关的主题：
* Java 社区
* 参与 Java 用户组
......@@ -12,19 +12,19 @@ Java 平台未来的关键是 Java 社区。这是本章的重点。我们将讨
# 技术要求
本章主要介绍 Java 11，Java 平台的**标准版**（**SE**）可从 Oracle 官网（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html) ).
本章介绍 Java 11，Java 平台的**标准版**（**SE**）可从 Oracle 官网（[下载 http://www.oracle.com/technetwork/java/javase/downloads/index.html](http://www.oracle.com/technetwork/java/javase/downloads/index.html)）。
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章相关的所有编码。IntelliJ IDEA 的社区版可从以下网站下载（[https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/) ).
IDE 软件包就足够了。来自 JetBrains 的 IntelliJ IDEA 用于与本章相关的所有编码。IntelliJ IDEA 的社区版可从以下网站下载（[https://www.jetbrains.com/idea/features/](https://www.jetbrains.com/idea/features/)）。
# Java 社区
Java 社区由数以百万计的开发人员组成，他们以一种或多种方式相互支持并为 Java 平台做出贡献。这就是 Java 是如此强大的开发平台的原因之一。社区参与可以包括在 Twitter 上以`@java`关注和参与，或在 Facebook 上喜欢`<3 Java`。
Java 社区由数以百万计的开发人员组成，他们以一种或多种方式相互支持并为 Java 平台做出贡献。这就是 Java 是如此强大的开发平台的原因之一。社区参与可以包括通过`@java`关注和参与 Twitter，或者在 Facebook 上喜欢`<3 Java`。
还有大量的列表服务、博客和论坛，您可以参与其中，帮助开发人员解答问题。这是一个很好的方法来支持社区并及时了解 Java 平台的变化。并不是所有 Oracle 的博客都是针对 Java 的，但至少是 Java 的附属博客。
您可以在[处浏览 Oracle 的博客目录 http://blogs.oracle.com。](http://blogs.oracle.com)
您可以在[浏览 Oracle 的博客目录 http://blogs.oracle.com。](http://blogs.oracle.com)
internet 上有几个 Java 论坛。Oracle 在[上拥有一个官方的 Java 社区空间 http://community.oracle.com](http://community.oracle.com) . Java 社区空间组织为以下空间：
internet 上有几个 Java 论坛。甲骨文在[开设了一个官方的 Java 社区空间 http://community.oracle.com](http://community.oracle.com)。Java 社区空间组织为以下空间：
| 爪哇 | Java 冠军 |
| #爪哇 20 | Java 社区进程 |
......@@ -41,7 +41,7 @@ internet 上有几个 Java 论坛。Oracle 在[上拥有一个官方的 Java 社
# 参与 Java 用户组
**Java 用户群**也被称为**JUGs**，由具有社区意识的 Java 专业人士组成，旨在分享他们的 Java 知识。有超过 200 个水壶，参与是自愿的。与其他专业用户群一样，JUGs 提供以下机会：
**Java 用户组**也被称为**JUGs**，由具有社区意识的 Java 专业人士组成，旨在分享他们的 Java 知识。有超过 200 个水壶，参与是自愿的。与其他专业用户群一样，JUGs 提供以下机会：
* 与其他 Java 专业人士联网
* 分享技巧、技巧和资源
......@@ -52,15 +52,15 @@ internet 上有几个 Java 论坛。Oracle 在[上拥有一个官方的 Java 社
# Java 社区进程
**Java 社区过程<sup>SM</sup>**（**JCP<sup>SM</sup>**是针对 Java 平台开发技术规范标准的结构化方法。所有开发者均可在[注册 http://jcp.org](http://jcp.org) . 注册后，用户可以查看**Java 规范请求**（**JSR**）并提交反馈
**Java 社区过程<sup>SM</sup>**（**JCP<sup>SM</sup>**是针对 Java 平台开发技术规范标准的结构化方法。所有开发者均可在[注册 http://jcp.org](http://jcp.org)。注册后，用户可以查看**Java 规范请求**（**JSR**）并提交反馈
此外，您甚至可以提交自己的 JSR 建议，并加入 JSRs 专家组。
此外，您甚至可以提交自己的 JSR 建议并加入 JSR 专家组。
在 JCP 站点，您可以搜索和浏览当前 jsr
# 技术网络
甲骨文拥有一个**甲骨文技术网络**（**OTN**），会员资格免费。详情请访问[https://www.oracle.com/technetwork/community/join/overview/index.html](https://www.oracle.com/technetwork/community/join/overview/index.html) .
甲骨文拥有一个**甲骨文技术网络**（**OTN**），其成员资格是免费的。详情请访问[https://www.oracle.com/technetwork/community/join/overview/index.html](https://www.oracle.com/technetwork/community/join/overview/index.html)。
OTN 会员有以下好处：
......@@ -84,7 +84,7 @@ OTN 会员有以下好处：
如果你是一个学者，专业人士，或只是想发表一篇文章，你可以提交给甲骨文。如果被接受，甲骨文将在 OTN 的保护下发布它们
以下网站提供了为 Oracle[撰写技术文章的详细信息 https://www.oracle.com/technetwork/articles/otn-submit-100481.html](https://www.oracle.com/technetwork/articles/otn-submit-100481.html) .
以下网站提供了为 Oracle[撰写技术文章的详细信息 https://www.oracle.com/technetwork/articles/otn-submit-100481.html](https://www.oracle.com/technetwork/articles/otn-submit-100481.html)。
本网站提供以下分类信息：
......@@ -108,9 +108,9 @@ OTN 会员有以下好处：
2. 有多少个罐子？
3. 水罐是如何组织的？
4. OTN 会员资格提供什么样的折扣？
5. 什么是**Java 社区进程<sup>SM</sup>**？
5. 什么是**Java 社区流程<sup>SM</sup>**？
6. Java 社区有多大？
7. 列出加入 JUG 的四个好处。
8. 在哪里可以了解更多有关为 Oracle 编写技术文章的信息？
8. 您可以从哪里了解到有关为 Oracle 编写技术文章的更多信息？
9. 向 JSR 提交反馈的先决条件是什么？
10. 谁可以提交 JSR？
\ No newline at end of file
new/master-java11/18.md
浏览文件 @ 51d73b2d
......@@ -17,10 +17,10 @@
1. 当一个线程在一个队列中等待一个当前被锁定的对象时，它就被认为是在争夺这个锁
2. 代码缓存是**Java 虚拟机**（**JVM**存储生成的本机代码的内存区域。
3. `-XX:NonProfiledCodeHeapSize` .
4. Lint 和 doclint 是向[0]报告警告的源。
5. `hotspot/test/testlibrary/jit-tester` .
6. `-Xshare:off` .
3. `-XX:NonProfiledCodeHeapSize`。
4. Lint 和 doclint 是向`javac`报告警告的来源。
5. `hotspot/test/testlibrary/jit-tester`。
6. `-Xshare:off`。
7. FXML 公司。
8. 在 Java9 之前，字符串数据存储为一个数组`chars`
9. 从 Java9 开始，字符串现在在内部使用字节数组和用于编码引用的标志字段来表示。
......@@ -28,15 +28,15 @@
# 第三章
1. 在 Java 中，围栏操作是`javac`以屏障指令的形式对内存进行强制约束的操作。这些操作发生在屏障指令之前和之后，本质上是将它们封闭起来。
1. 在 Java 中，fence 操作是`javac`以 barrier 指令的形式对内存进行强制约束的操作。这些操作发生在屏障指令之前和之后，本质上是将它们封闭起来。
2. projectcoin 是 java7 中引入的一组小改动的特性集。
3. 从 Java9 开始，我们可以对私有实例方法使用[0]注释。
3. 从 Java9 开始，我们可以对私有实例方法使用`@SafeVarargs`注释。
4. 从 Java9 开始，我们在类和文件中列出 import 语句的顺序将不再影响编译过程。
5. Java 平台在`cacerts`密钥库中包含一组根证书。
6. [0]标识符在技术上是一个保留的类型名。
7. 可以通过使用新的[0]标识符来推断声明。
8. 下划线字符（[0]）不能再用作合法的标识符名称。
9. [0]包是 12 个子类的集合，它们支持对线程安全和无锁的单个变量执行操作。
6. `var`标识符在技术上是一个保留的类型名。
7. 可以通过使用新的`var`标识符来推断声明。
8. 下划线字符（`_`）不能再用作合法的标识符名称。
9. `java.util.concurrent.atomic`包是 12 个子类的集合，支持对线程安全和无锁的单个变量执行操作。
10. 变量处理程序是对变量的类型化引用，由`java.lang.invoke.VarHandle`抽象类控制。
# 第四章
......@@ -48,25 +48,25 @@
* 编译时操作必须能够识别正在使用的模块
* 对模块的运行时支持
3. Java 模块是以下集合：
3. Java 模块是以下内容的集合：
* 包装
* 班级
* 接口
* 代码
* 数据
* 资源
4. `java` .
4. `java`。
5. JDK 的主要组件如下：
* 开发工具
* JavaFX 工具
* **Java 运行时环境**（**JRE**）
* 源代码
* 图书馆
* C 标题文件
* C 头文件
* 数据库
6. 可维护性、性能和安全性。
7. `bin`、`conf`和`lib`。
8. `bin` , `conf` , `lib` , `demo` , `sample` , `man` , `include` .
8. `bin`、`conf`、`lib`、`demo`、`sample`、`man`、`include`。
9. 链接时间。
10. Java 链接器。
......@@ -75,11 +75,11 @@
1. 当开发计算机上有多个版本的库时，库信息的特殊性不足，类加载器有问题，类路径过长。
2. Java 9。
3. 模块通过提供强大的封装解决了 java9jdk 之前的单片问题。
4. `java.base` .
4. `java.base`。
5. Java 中的封装是由`module-info.java`文件中的信息驱动的。
6. `jdk.unsupported`JDK 模块。
7. `module-info.java` .
7. `module-info.java`。
8. Java 网络启动协议（**JNLP**）。
9. 它是一个非法的标识符，从 Java10 开始。
10. `--add-opens`、`--add-exports`和`--permit-illegal-access`。
......@@ -97,13 +97,13 @@
4. JShell 是位于/bin 文件夹中的命令行工具。
5. 退出 shell 就像进入`/exit`一样简单。
6. `/vars` .
7. 在 JShell 中输入[0]或[1]命令可以提供一个完整的命令列表和可以在 shell 中使用的语法。
8. 您可以在 JShell 中使用[0]命令，然后使用需要额外帮助的命令来获得额外的帮助。
9. 命令行工具通常会提供相对稀疏的反馈，以避免
屏幕过度拥挤或成为开发人员的麻烦。JShell 有
几种反馈模式，除了让开发人员能够
创建自己的定制模式之外。
6. `/vars`。
7. 在 JShell 中输入`/help`或`/?`命令提供了一个完整的命令列表和可以在 shell 中使用的语法。
8. 在 JShell 中，可以使用`/help`命令，然后使用需要额外帮助的命令来获得额外的帮助。
9. 命令行工具通常提供相对稀疏的反馈，以避免
屏幕过度拥挤，或者对开发人员造成麻烦。JShell 有
几种反馈模式，除了让开发人员能够创建
自己的定制模式之外。
10. 反馈方式有四种：`concise`、`normal`、`silent`、`verbose`。
# 第七章
......@@ -117,31 +117,31 @@
* G1 垃圾回收
2. G1 名称首先引用垃圾。
3. **iCMS**（简称**增量并标记ਣ描**模适量较少
3. **iCMS**（增量并发标记扫描】）、【CPU】、【37327】、【36739】、【35813】、
4. MiB 代表 Mebibyte*，*是数字信息字节的倍数。
5. 虽然垃圾回收在 Java 中是自动的，但是您可以显式调用
方法`java.lang.System.gc()`来帮助调试过程。此方法不接受任何参数，也不返回任何值。
5. 尽管垃圾收集在 Java 中是自动的，但是您可以显式调用
方法`java.lang.System.gc()`方法来帮助调试过程。此方法不接受任何参数，也不返回任何值。
6. 因为 Java 中的所有对象，即使是您自己创建的对象，都是`java.lang.Object`的子类，所以 Java 中的每个对象都有一个`finalize()`方法。
6. 因为 Java 中的所有对象，甚至是您自己创建的对象，都是`java.lang.Object`的子类，所以 Java 中的每个对象都有一个`finalize()`方法。
7. 这些组合在 Java9 中已被删除。
8. `CollectedHeap`类。
8. `CollectedHeap`班。
9. 对于 java10，g1full 垃圾回收器被转换为 parallel，以减轻对使用 full 垃圾回收的开发人员的任何负面影响。
10. εGC。
# 第 8 章
1. 微基准是用来测试系统性能的。这与宏基准测试不同，宏基准测试在不同平台上运行测试，以进行效率比较和后续分析。通过微包标记，我们通常针对一个系统上的特定代码片段，例如方法或循环。微包装的主要目的是在代码中识别优化机会。
1. 微基准是用来测试系统性能的。这与宏观基准测试不同，后者在不同的平台上运行测试，以进行效率比较和后续分析。使用微标记，我们通常针对一个系统上的特定代码片段，例如方法或循环。微基准的主要目的是在我们的代码中识别优化机会。
2. 微基准发生在流程设计、实现、执行、分析和增强的几个阶段。
3. Maven，也称为 apachemaven，是一个项目管理和理解工具，我们可以使用它来管理我们的应用程序项目构建、报告和文档。
4. `pom.xml` .
4. `pom.xml`。
5. 它们都是可配置的选项。
6. All、AverageTime、SampleTime、SingleShotTime 和吞吐量。
7. 纳秒、微秒、毫秒、秒、分、小时、天。
7. 纳秒，微秒，毫秒，秒，分钟，小时，天。
8. 对于电源管理陷阱，有两种建议策略：
* 在运行测试之前禁用任何电源管理系统
......@@ -152,7 +152,7 @@
* 优化系统调度策略
* 长时间运行基准测试
10. 对时间共享陷阱有两种建议策略：
10. 对于分时陷阱，有两种建议策略：
* 在运行基准测试之前测试所有代码，以确保一切正常工作
* 只有当所有线程都已启动或停止时，才使用 JMH 进行测量
......@@ -163,21 +163,21 @@
2. Java9 中引入了两个支持处理操作系统进程的新接口：`ProcessHandle`和`ProcessHandle.Info`。
3. 当进程结束时，`handle.is.Alive()`方法返回 false。
3. 处理完成后，`handle.is.Alive()`方法返回 false。
4. 我们可以通过句柄访问进程的 PID。
`handle.getPid()`方法返回`Long`，表示 PID 的数值。
5. 要获取当前进程的 PID，可以使用调用链`ProcessHandle.current().getPid()`。
5. 为了得到当前进程的 PID，可以使用调用链`ProcessHandle.current().getPid()`。
6. `command()` , `arguments()` , `commandLine()` , `startInstant()` , `totalCpuDuration()` , `user()` .
7. 要获得控制子级的工艺手柄`Stream`，应采用静态法`processHandle.children()`。
6. `command()`、`arguments()`、`commandLine()`、`startInstant()`、`totalCpuDuration()`、`user()`。
7. 为了得到控制子进程的进程句柄的`Stream`，应该使用静态方法`processHandle.children()`。
8. `processHandle.descendants()` .
8. `processHandle.descendants()`。
9. `allProcess()` .
9. `allProcess()`。
10. `CompletableFuture` .
10. `CompletableFuture`。
# 第十章
......@@ -187,23 +187,23 @@
这个调用返回序列是使用本机方法栈维护的，就像其他 C 程序一样。
3. Java 虚拟机`Stack`。
4. 在 Java 中，我们使用 API 来获取`Logger`。使用 API，模块可以为服务`LoggerFinder`提供实现，服务`LoggerFinder`又可以返回实现`getLogger()`方法的`Logger`。
4. 在 Java 中，我们使用 API 来获取`Logger`。使用 API，模块可以为服务`LoggerFinder`提供实现，而服务`LoggerFinder`又可以返回实现`getLogger()`方法的`Logger`。
5. `StackWalker`类。
5. `StackWalker`班。
6. `RETAIN_CLASS_REFERENCE`、`SHOW_REFLECT_FRAMES`和`SHOW_HIDDEN_FRAMES`。
7. 如果我们将第一个选项 enum constant`RETAIN_CLASS_REFERENCE`指定为`getInstance()`方法的参数，则返回的实例将授予我们访问各个堆栈在遍历期间引用的类的权限。
7. 如果我们指定第一个选项 enum constant，`RETAIN_CLASS_REFERENCE`作为`getInstance()`方法的参数，那么返回的实例将授予我们访问各个堆栈在遍历期间引用的类的权限。
8. [0]enum 常量将生成一个 walker，其中包含来自某个反射调用的帧。
8. `SHOW_REFLECT_FRAMES`enum 常量将生成一个 walker，其中包含来自某个反射调用的帧。
9. 枚举常量选项`SHOW_HIDDEN_FRAMES`将包括所有隐藏帧，其中包含反射调用以及为 Lambda 函数调用生成的调用帧。
10. [0]类是最终类，不能扩展。
10. `StackWalker`类是最终类，不能扩展。
# 第十一章
1. 易用性。
2. API 未公开 HTTP 协议的约 10%：
2. 大约 10%的 HTTP 协议未被 API 公开：
* 标准/通用身份验证机制仅限于基本身份验证
* 性能改进可能无法实现
* 不支持对请求进行筛选
......@@ -212,7 +212,7 @@
* 缺乏通用的升级机制
3. 包名、源文件名、访问控制选项。
4. `languageVersion()` , `optionLength(String option)` , `start(RootDoc root)` , `validOptions(String[][] options, DocErrorReporter reporter)` .
4. `languageVersion()`、`optionLength(String option)`、`start(RootDoc root)`、`validOptions(String[][] options, DocErrorReporter reporter)`。
5. `AttributeTree.ValueKind`和`DocTree.Kind`。
6. HTML5。
......@@ -230,8 +230,8 @@
2. 数据流是字符串和基本数据类型的二进制输入/输出。
3. 效率。
4. 以下是不需要的数据缓冲、数据转换和转换。
5. `java.util.concurrent` .
6. `Flow.Publisher` , `Flow.Subscriber` , `Flow.Subscription` , `Flow.Processor` .
5. `java.util.concurrent`。
6. `Flow.Publisher`、`Flow.Subscriber`、`Flow.Subscription`、`Flow.Processor`。
7. 多个进程共享一个处理器。
8. 并发性和并行性经常被用作可互换的术语。并发是指当多个进程重叠时，尽管开始和停止时间可能不同。并行性发生在任务同时启动、运行和停止时。
9. 共享内存系统配置有多个处理器，所有处理器共享一个公共系统内存。
......@@ -243,7 +243,7 @@
2. **传输层安全**（**TLS**）是最常见的网络安全协议。
3. 在实现握手重新协商时，始终实现[0]扩展。
3. 在实现握手重新协商时，始终实现`renegotiation_info`扩展。
4. 实现 FS 可以确保过去的会话加密密钥不会在长期加密密钥受损时受损。
......@@ -251,7 +251,7 @@
6. `KeyStore`将存储在`/jre/lib/security/cacerts`文件夹中。
7. 当您想要延迟`KeyStore`的实例化时，使用`KeyStore.Builder`类。
7. `KeyStore.Builder`类用于延迟`KeyStore`的实例化。
8. 它具有以下特点：
* 线程安全的
......@@ -280,7 +280,7 @@
# 第 15 章
1. **Unicode 转换格式-8**（**UTF-8**）是一个字符集，它用一到四个 8 位字节封装所有 Unicode 字符。它是 Unicode 的面向字节的编码形式。
1. **Unicode 转换格式-8**（**UTF-8**）是一个字符集，它使用一到四个 8 位字节封装所有 Unicode 字符。它是 Unicode 的面向字节的编码形式。
2. 以下是 UTF-8 的一些特点：
* 可以对所有 1112064 Unicode 代码点进行编码
......@@ -288,7 +288,7 @@
* 占所有网页的近 90%
* 向后兼容 ASCII
* 是可逆的
3. `ResourceBundle`类。
3. `ResourceBundle`班。
4. 没有什么。
5. 基于给定`baseName`和默认`locale`的资源包
6. Java 18.9（Java 11）支持 Unicode 10.0.0，于 2017 年 6 月 20 日发布。
......@@ -298,7 +298,7 @@
* C2 JIT 编译器
8. 多分辨率图像包含同一图像的多个分辨率变体。
9. `java.awt.Graphics`类用于从多分辨率图像中检索所需的变量。
10. **CLDR**（简称**Common Locale Data Repository**）是许多支持多种语言的软件应用程序的关键组件，被吹捧为最大的 Locale Data Repository，被众多大型软件供应商使用，包括 Apple、Google、IBM 和 Microsoft。
10. **CLDR**（简称**Common Locale Data Repository**）是许多支持多种语言的软件应用程序的关键组件，被吹捧为最大的 Locale Data Repository，被众多大型软件供应商使用，包括苹果、谷歌、IBM 和微软。
# 第十六章
......@@ -313,8 +313,8 @@
6. 一旦 JEP 被认为准备好进行正式评估，提交人就会设置这种状态。
7. 一旦 OpenJDK 负责人接受了 JEP，它就变为这个状态。
8. Funded Funded 表示职能部门领导或集团领导已判断 JEP 获得全额资助。
9. 已完成此状态表示增强功能的工作已完成并在版本发布中交付。
10. [http://openjdk.java.net/jeps/0](http://openjdk.java.net/jeps/0) .
9. 已完成此状态表示增强工作已在版本发布中完成并交付。
10. [http://openjdk.java.net/jeps/0](http://openjdk.java.net/jeps/0)。
# 第十七章
......@@ -331,6 +331,6 @@
* 向他人学习
* 增加 Java 知识
8. [https://www.oracle.com/technetwork/articles/otn-submit-100481.html](https://www.oracle.com/technetwork/articles/otn-submit-100481.html) .
9. 在[处注册 http://jcp.org](http://jcp.org) .
8. [https://www.oracle.com/technetwork/articles/otn-submit-100481.html](https://www.oracle.com/technetwork/articles/otn-submit-100481.html)。
9. 在[登记 http://jcp.org](http://jcp.org)。
10. 任何注册会员
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或