Hello, world
\n" + 32 | " \n" + 33 | "\n"; 34 | 35 | // 使用“二维”文本块 36 | String html = """ 37 | 38 | 39 |Hello, world
40 | 41 | 42 | """; 43 | ``` 44 | 45 | **SQL示例** 46 | 47 | ```sql 48 | // 使用“一维”字符串文字 49 | String query = "SELECT \"EMP_ID\", \"LAST_NAME\" FROM \"EMPLOYEE_TB\"\n" + 50 | "WHERE \"CITY\" = 'INDIANAPOLIS'\n" + 51 | "ORDER BY \"EMP_ID\", \"LAST_NAME\";\n"; 52 | 53 | // 使用“二维”文本块 54 | String query = """ 55 | SELECT "EMP_ID", "LAST_NAME" FROM "EMPLOYEE_TB" 56 | WHERE "CITY" = 'INDIANAPOLIS' 57 | ORDER BY "EMP_ID", "LAST_NAME"; 58 | """; 59 | ``` 60 | 61 | **Polyglot语言示例** 62 | 63 | ```polyglot 64 | // 使用“一维”字符串文字 65 | ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); 66 | Object obj = engine.eval("function hello() {\n" + 67 | " print('\"Hello, world\"');\n" + 68 | "}\n" + 69 | "\n" + 70 | "hello();\n"); 71 | 72 | // 使用“二维”文本块 73 | ScriptEngine engine = new ScriptEngineManager().getEngineByName("js"); 74 | Object obj = engine.eval("function hello() {\n" + 75 | " print('\"Hello, world\"');\n" + 76 | "}\n" + 77 | "\n" + 78 | "hello();\n"); 79 | ``` 80 | 81 | ## 编译时处理 82 | 83 | 文本块是String类型的常量表达式，类似于字符串字面量。然而，与字符串字面值不同，文本块的内容在编译时经历三个步骤的处理：==行终止符的规范化==、==附带白色空间的移除==和==解释转义序列==： 84 | 85 | 1. 转换内容的行终止符 86 | * 行终止符从CR（\u000D）和CRLF（\u000D\u000A）规范化为`LF（\u000A）` 87 | 2. 删除内容周围附带的白色空间（用于匹配Java源代码的缩进） 88 | 3. 解释内容中的转义序列，执行解释作为最后一步开发人员可以编写转义序列，如\n，而不会被前面的步骤修改或删除 89 | 90 | 处理后的内容以`CONSTANT_String_info`形式记录在**类文件的常量池**中，运行时，文本块被计算为String的实例。 91 | 92 | ## 新增转义序列 93 | 94 | 为了更精细地控制==换行符==和==空格==的处理，引入了两个新的转义序列：\{@code
34 | * 源代码行1
35 | * ...
36 | * 源代码行n
37 | * }
38 | ```
39 |
40 | ## 引入@snippet标签
41 |
42 | 解决了`@code`标签的不足，允许在API文档中直接嵌入代码片段，以便更好地展示API的使用方法。
43 |
44 | ```java
45 | /**
46 | * 以下代码显示了如何使用 {@code Optional.isPresent}:
47 | * {@snippet :
48 | * if (v.isPresent()) {
49 | * System.out.println("v: " + v.get());
50 | * }
51 | * }
52 | */
53 | ```
54 |
55 | 作为外部片段导入
56 |
57 | ```java
58 | /**
59 | * 以下代码显示了如何使用 {@code Optional.isPresent}:
60 | * {@snippet file="ShowOptional.java" region="example"}
61 | */
62 | ```
63 |
64 | 其中`ShowOptional.java`是一个包含以下内容的文件：
65 |
66 | ```java
67 | public class ShowOptional {
68 | void show(Optional\{text}
168 | 169 | 170 | """; 171 | | 输出结果： 172 | | """ 173 | | 174 | | 175 | |Hello, world
179 | | 180 | | 181 | | """ 182 | 183 | // 多行模板表达式示例：JSON文档 184 | String name = "Joan Smith"; 185 | String phone = "555-123-4567"; 186 | String address = "1 Maple Drive, Anytown"; 187 | String json = STR.""" 188 | { 189 | "name": "\{name}", 190 | "phone": "\{phone}", 191 | "address": "\{address}" 192 | } 193 | """; 194 | | 输出结果： 195 | | """ 196 | | { 197 | | "name": "Joan Smith", 198 | | "phone": "555-123-4567", 199 | | "address": "1 Maple Drive, Anytown" 200 | | } 201 | | """ 202 | 203 | record Rectangle(String name, double width, double height) { 204 | double area() { 205 | return width * height; 206 | } 207 | } 208 | Rectangle[] zone = new Rectangle[] { 209 | new Rectangle("Alfa", 17.8, 31.4), 210 | new Rectangle("Bravo", 9.6, 12.4), 211 | new Rectangle("Charlie", 7.1, 11.23), 212 | }; 213 | // 多行模板表达式示例：表格 214 | String table = STR.""" 215 | Description Width Height Area 216 | \{zone[0].name} \{zone[0].width} \{zone[0].height} \{zone[0].area()} 217 | \{zone[1].name} \{zone[1].width} \{zone[1].height} \{zone[1].area()} 218 | \{zone[2].name} \{zone[2].width} \{zone[2].height} \{zone[2].area()} 219 | Total \{zone[0].area() + zone[1].area() + zone[2].area()} 220 | """; 221 | | 输出结果： 222 | | """ 223 | | Description Width Height Area 224 | | Alfa 17.8 31.4 558.92 225 | | Bravo 9.6 12.4 119.03999999999999 226 | | Charlie 7.1 11.23 79.733 227 | | Total 757.693 228 | | """ 229 | ``` 230 | 231 | ## FMT模板处理器 232 | 233 | 除了STR模版处理器之外，Java中还提供了另外一个模版处理器：FMT。 234 | FMT与STR相似之处在于它执行插值，但还提供了==格式化处理==能力。 235 | 236 | * 格式说明符与`java.util.Formatter`中定义的格式说明符相同 237 | 238 | ```java 239 | record Rectangle(String name, double width, double height) { 240 | double area() { 241 | return width * height; 242 | } 243 | } 244 | Rectangle[] zone = new Rectangle[] { 245 | new Rectangle("Alfa", 17.8, 31.4), 246 | new Rectangle("Bravo", 9.6, 12.4), 247 | new Rectangle("Charlie", 7.1, 11.23), 248 | }; 249 | // 多行模板表达式示例：表格 250 | String table = FMT.""" 251 | Description Width Height Area 252 | %-12s\{zone[0].name} %7.2f\{zone[0].width} %7.2f\{zone[0].height} %7.2f\{zone[0].area()} 253 | %-12s\{zone[1].name} %7.2f\{zone[1].width} %7.2f\{zone[1].height} %7.2f\{zone[1].area()} 254 | %-12s\{zone[2].name} %7.2f\{zone[2].width} %7.2f\{zone[2].height} %7.2f\{zone[2].area()} 255 | \{" ".repeat(28)} Total %7.2f\{zone[0].area() + zone[1].area() + zone[2].area()} 256 | """; 257 | | 输出结果： 258 | | """ 259 | | Description Width Height Area 260 | | Alfa 17.80 31.40 558.92 261 | | Bravo 9.60 12.40 119.04 262 | | Charlie 7.10 11.23 79.73 263 | | Total 757.69 264 | | """ 265 | ``` 266 | -------------------------------------------------------------------------------- /src/md/java-features/Java21/jep431-sequenced-collections.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Java 21 新特性：有序集合 3 | shortTitle: 4 | description: 5 | icon: 6 | cover: 7 | author: 流浪码客 8 | isOriginal: true 9 | sticky: false 10 | star: false 11 | date: 2024-01-07 12 | category: Java Features 13 | tag: 14 | - java 15 | order: 431 16 | --- 17 | 18 | # Java 21 新特性：有序集合（Sequenced Collections） 19 | 20 | 在JDK 21中，**有序集合**（Sequenced Collections）引入了新的接口和方法来简化集合处理。 21 | 22 | > 此增强功能旨在解决访问Java中各种集合类型的第一个和最后一个元素需要非统一且麻烦处理场景 23 | 24 | `Sequenced Collections` 引入如下 3 个新接口，用于处理顺序`List`、`Set`和`Map`， 25 | 并将它们整合到现有的集合类型中。这些新接口中的方法都具有默认实现。 26 | 27 | 1. SequencedCollection 28 | 2. SequencedSet 29 | 3. SequencedMap 30 | 31 | ## SequencedCollection 32 | 33 | 提供了在集合两端添加、检索和移除元素的方法，沿着`reversed()`方法提供了该集合的逆序视图。 34 | 35 | ```java 36 | interface SequencedCollection资源有限 (例如单核)
暂停时间短 | 89 | | Parallel | 多核系统上的峰值性能
非常适合高计算负载
暂停时间 > 1秒是可以接受的 | 90 | | G1
CMS | 响应时间 > 吞吐量
堆内存较大
暂停时间 < 1秒 | 91 | | Shenandoah | 尽量减少暂停时间
可预测的延迟 | 92 | | ZGC | 响应时间是高优先级的，和/或
非常大的堆内存 | 93 | | Epsilon GC | 性能测试和故障排除 | 94 | 95 | 每种方法都有自己的优点和缺点，这在很大程度上取决于应用程序的需求和可用资源。 96 | 97 | ## 分代ZGC 98 | 99 | Java 11引入的实验性功能**ZGC**是一种**非分代**的垃圾收集方法。 100 | 尽管如此，它在**GC暂停**时间方面仍然带来了显著改进，至少在资源足够的情况下，可以比并发线程消耗内存更快地回收内存。 101 | 缺点是，它将所有对象存储在一起，而不考虑年龄，因此每个周期都会收集所有对象。 102 | 103 | [generational hypothesis](https://www.memorymanagement.org/glossary/g.html#generational.hypothesis) 104 | 观察到==年轻对象==比==年长对象==更有可能“**早逝**”，于是产生了分代假设。 105 | 106 | Java 21 中，**分代 ZGC** 将堆分为两个逻辑代：一个用于最近分配的对象，另一个用于长期存活对象。 107 | GC 可以专注于更频繁地收集**年轻**(最近分配)且更有**前途**(可能长期存在)的对象，而不会增加GC暂停时间，将其保持在 1 毫秒以下。 108 | 109 | **分代ZGC**与非分代ZGC相比的关键优势： 110 | 111 | * 减少分配停滞的风险 112 | * 降低堆内存开销要求 113 | * 减少垃圾回收CPU开销 114 | 115 | 此外，目标是在保留非分代方法已有优势的基础上实现这些优势： 116 | 117 | * 暂停时间保持在在 1 毫秒以下 118 | * 支持多达数万TB的堆大小 119 | * 最少的手动配置 120 | 121 | 为了保持最后一点，新的GC不需要手动配置代的大小、GC使用的线程数，或对象在年轻代中停留的时间。 122 | 123 | ## 如何使用 JVM GC 124 | 125 | 在Java 21中，分代ZGC是默认的垃圾收集器。为了顺利过渡，分代ZGC将与非分代ZGC一起提供，您可以通过以下方式进行配置： 126 | 127 | ```shell 128 | # 启用ZGC(默认为非分代) 129 | $ java -XX:+UseZGC 130 | 131 | # 使用分代ZGC 132 | $ java -XX:+UseZGC -XX:+ZGenerational 133 | ``` 134 | 135 | 如果您需要关闭分代ZGC，可以通过将加号（+）替换为减号（-）来实现： 136 | 137 | ```shell 138 | # 不使用分代ZGC 139 | $ java -XX:+UseZGC -XX:-ZGenerational 140 | ``` 141 | 142 | 计划在更晚的版本中完全删除非分代ZGC。 143 | -------------------------------------------------------------------------------- /src/md/java-features/Java21/jep440-record-partterns.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Java 21 新特性：记录模式 3 | shortTitle: 4 | description: 5 | icon: 6 | cover: 7 | author: 流浪码客 8 | isOriginal: true 9 | sticky: false 10 | star: false 11 | date: 2024-01-09 12 | category: Java Features 13 | tag: 14 | - java 15 | order: 440 16 | --- 17 | 18 | # Java 21 新特性：记录模式（Record Patterns） 19 | 20 | Java 21 中的**记录模式**（Record Patterns）是对模式匹配的扩展，它允许在模式匹配中使用**记录**（Records）类型。 21 | 同时，记录模式还支持嵌套，可以实现更复杂的数据查询和处理。 22 | 23 | ## 仅仅是类型匹配 24 | 25 | 到目前为止，Java中的模式匹配主要局限于匹配类型：[instanceof类型匹配](/java-features/Java16/jep394-pattern-matching-for-instanceof) 26 | 27 | ```java 28 | // Java 16 之前 29 | if (obj instanceof String) { 30 | String str = (String) obj; 31 | System.out.println(str); 32 | } 33 | 34 | // JAVA 16+ 35 | if (obj instanceof String str) { 36 | System.out.println(str); 37 | } 38 | ``` 39 | 40 | Java 41 | 21扩展了这个概念，使其可用于switch语句和表达式: [switch的模式匹配](/java-features/Java21/jep441-pattern-matching-for-switch) 42 | 43 | ```java 44 | // JAVA 21之前 45 | static String asStringValue(Object anyValue) { 46 | String result = null; 47 | if (anyValue instanceof String str) { 48 | result = str; 49 | } else if (anyValue instanceof BigDecimal bd) { 50 | result = bd.toEngineeringString(); 51 | } else if (anyValue instance Integer i) { 52 | result = Integer.toString(i); 53 | } else { 54 | result = "n/a"; 55 | } 56 | return result; 57 | } 58 | 59 | // JAVA 21+ 60 | static String asStringValue(Object anyValue) { 61 | return switch (anyValue) { 62 | case String str -> str; 63 | case BigDecimal bd -> bd.toEngineeringString(); 64 | case Integer i -> Integer.toString(i); 65 | default -> "n/a"; 66 | }; 67 | } 68 | ``` 69 | 70 | 代码比之前更加简洁，同时也更加易读。但是，这种模式匹配仍然局限于类型匹配。 71 | 72 | ## record模式 73 | 74 | 当我们将模式匹配与记录类型结合使用时，我们称之为**记录模式**。这意味着我们可以在模式匹配中使用记录类型，以及记录类型的属性。 75 | 76 | ```java 77 | record Point(int x, int y) {} 78 | 79 | // Java 16 之前 80 | static void printSum(Object obj) { 81 | if (obj instanceof Point p) { 82 | int x = p.x(); 83 | int y = p.y(); 84 | System.out.println(x+y); 85 | } 86 | } 87 | 88 | // JAVA 21+ 89 | static void printSum(Object obj) { 90 | if (obj instanceof Point(int x, int y)) { 91 | System.out.println(x+y); 92 | } 93 | } 94 | ``` 95 | 96 | 其中`Point(int x, int y)`就是记录模式，它匹配`Point`类型的对象，将记录的实例（obj）分解到它的组件（`x`和`y`）。 97 | 98 | ## 嵌套record的解构 99 | 100 | 假设我们设计了一个记录，表示一个矩形，其中包含左上角和右下角的颜色点。 101 | 如果我们想要获取左上角点的颜色，我们可以这样写： 102 | 103 | ```java 104 | record Point(int x, int y) {} 105 | enum Color { RED, GREEN, BLUE } 106 | record ColoredPoint(Point p, Color c) {} 107 | record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {} 108 | 109 | Rectangle r = new Rectangle(new ColoredPoint(new Point(x1, y1), c1), 110 | new ColoredPoint(new Point(x2, y2), c2)); 111 | 112 | // Java 16 之前 113 | static void printUpperLeftColoredPoint(Rectangle r) { 114 | if (r instanceof Rectangle(ColoredPoint ul, ColoredPoint lr)) { 115 | System.out.println(ul.c()); 116 | } 117 | } 118 | 119 | // JAVA 21+ 120 | static void printUpperLeftColoredPoint(Rectangle r) { 121 | if (r instanceof Rectangle(ColoredPoint(Point ul, Color c), ColoredPoint lr)) { 122 | System.out.println(c); 123 | } 124 | } 125 | ``` 126 | 127 | 嵌套模式允许我们使用与将其组合的代码一样清晰简洁的代码来拆解聚合。 128 | 129 | ## 发展脉络 130 | 131 | 该功能最初作为预览功能在Java 19（JEP 405）中首次亮相，随后经过Java 20（JEP 432）的迭代，最终在Java 21中定稿（JEP 440）。 132 | 此功能与模式匹配的switch语句（JEP 441）共同演进，并且它们之间存在相当大的互动。 133 | -------------------------------------------------------------------------------- /src/md/java-features/Java21/jep441-pattern-matching-for-switch.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Java 21 新特性：switch模式匹配 3 | shortTitle: 4 | description: 5 | icon: 6 | cover: 7 | author: 流浪码客 8 | isOriginal: true 9 | sticky: false 10 | star: false 11 | date: 2024-01-10 12 | category: Java Features 13 | tag: 14 | - java 15 | order: 441 16 | --- 17 | 18 | # Java 21 新特性：switch模式匹配 19 | 20 | Java 21 引入了 switch 模式匹配功能，它增强了 switch 语句的功能，允许使用更简洁的语法来执行类型检查和数据提取。 21 | 该功能与[记录模式（JEP 440）](/java-features/Java21/jep440-record-partterns)共同发展，并与之有相当大的互动。 22 | 23 | 24 | ## switch + instanceof 25 | 26 | 与if条件中的`instanceof`一样，`switch case`现在可以对其值进行类型检查，并创建一个case作用域变量: 27 | 28 | ```java 29 | static String asStringValue(Object anyValue) { 30 | return switch (anyValue) { 31 | case String str -> str; 32 | case JSONObject json -> json.toCompactString(); 33 | case BigDecimal bd -> bd.toEngineeringString(); 34 | case Integer i -> Integer.toString(i); 35 | case LocalDate ld -> ld.format(DateTimeFormatter.ISO_LOCAL_DATE); 36 | default -> "n/a"; 37 | }; 38 | } 39 | ``` 40 | 41 | ## switch + null 42 | 43 | ```java 44 | static String asStringValue(Object anyValue) { 45 | return switch (anyValue) { 46 | case null -> "n/a"; 47 | case String str -> str; 48 | ... 49 | }; 50 | } 51 | ``` 52 | 53 | ## switch + enum 54 | 55 | ```java 56 | sealed interface CardClassification permits Suit, Tarot {} 57 | public enum Suit implements CardClassification { CLUBS, DIAMONDS, HEARTS, SPADES } 58 | final class Tarot implements CardClassification {} 59 | 60 | static void exhaustiveSwitchWithBetterEnumSupport(CardClassification c) { 61 | switch (c) { 62 | case CLUBS -> System.out.println("梅花"); 63 | case DIAMONDS -> System.out.println("方块"); 64 | case HEARTS -> System.out.println("红桃"); 65 | case SPADES -> System.out.println("黑桃"); 66 | case Tarot t -> System.out.println("塔罗牌"); 67 | default -> System.out.println("未知的卡片类型"); 68 | } 69 | } 70 | ``` 71 | 72 | -------------------------------------------------------------------------------- /src/md/java-features/Java21/jep444-virtual-threads.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Java 21 新特性：虚拟线程 3 | shortTitle: 4 | description: 5 | icon: 6 | cover: 7 | author: 流浪码客 8 | isOriginal: true 9 | sticky: false 10 | star: false 11 | date: 2024-01-11 12 | category: Java Features 13 | tag: 14 | - java 15 | order: 444 16 | --- 17 | 18 | # Java 21 新特性：虚拟线程（Virtual Threads） 19 | 20 | Java 21 引入了**虚拟线程**（Virtual Threads）功能，类似于Go语言中的`Goroutines`。 21 | 虚拟线程是一种轻量级的线程，它可以极大地减少了编写、维护和管理高吞吐量并发应用程序所需的工作量。 22 | 23 | Java平台目前为止有两种类型的线程：**传统线程**，也称为==平台线程==，和**虚拟线程**。 24 | 25 | ## 平台线程 26 | 27 | 在引入虚拟线程之前，我们所使用的线程`java.lang.Thread`是由所谓的平台线程支持的。 28 | 29 | 这些线程通常是 1:1 映射到操作系统线程的，因此它们是重量级的，创建和销毁线程的开销很大。 30 | 且每个请求都需要一个独立的线程，这会导致线程资源的快速耗尽，从而限制了应用程序的可伸缩性。 31 | 32 | ### 创建平台线程 33 | 34 | ```java 35 | Thread thread = new Thread(() -> { 36 | // 由平台线程执行的代码 37 | }).start(); 38 | ``` 39 | 40 | 随着[Project Loom](https://openjdk.org/projects/loom/)简化了新的并发方法，它还提供了一种新的方法来创建平台支持的线程： 41 | 42 | ```java 43 | Thread thread = Thread.ofPlatform() 44 | .start(runnable); 45 | 46 | // 或者 47 | Thread thread = Thread.ofPlatform(). 48 | .daemon() 49 | .name("platform-thread") 50 | .unstarted(runnable); 51 | ``` 52 | 53 | ## 虚拟线程 54 | 55 | 虚拟线程是JDK提供的**轻量级线程**实现，可以在同一个OS线程上运行许多虚拟线程。 56 | 虚拟线程为平台线程提供了一种更有效的替代方案，允许开发人员以显著降低的开销处理大量任务。 57 | 这些线程提供了与现有Java代码的兼容性和无缝迁移路径，从而从增强的性能和资源利用率中获益。 58 | 59 | 许多语言中都有某种形式的轻量级线程： 60 | 61 | * Go语言的[Goroutines](https://go.dev/tour/concurrency/1) 62 | * Erlang的[Erlang Processes](https://www.erlang.org/docs/23/efficiency_guide/processes.html) 63 | * Haskell的[Haskell Threads](https://wiki.haskell.org/Lightweight_concurrency) 64 | * 等等 65 | 66 | ### 创建虚拟线程 67 | 68 | 1. 使用`Thread.startVirtualThread()`方法创建虚拟线程： 69 | 70 | ```java 71 | // 使用静态构建器方法 72 | Thread.startVirtualThread(() -> { 73 | // 由虚拟线程执行的代码 74 | }); 75 | ``` 76 | 77 | 也可以使用`Thread.ofVirtual()`来创建，这里还可以设置一些属性，比如：线程名称等。具体如下代码： 78 | 79 | ```java 80 | Thread virtualThread = Thread.ofVirtual() 81 | .name("virtual-thread") 82 | .start(runnable); 83 | ``` 84 | 85 | 2. 使用`ExecutorService`创建虚拟线程： 86 | 87 | 从Java 5开始，就推荐开发人员使用`ExecutorServices`而不是直接使用`Thread`类了。 88 | 现在，Java 21中引入了使用虚拟线程，所以也有了新的ExecutorService来适配，看看下面的例子： 89 | 90 | ```java 91 | try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) { 92 | IntStream.range(0, 10_000).forEach(i -> { 93 | executor.submit(() -> { 94 | Thread.sleep(Duration.ofSeconds(1)); 95 | return i; 96 | }); 97 | }); 98 | } // executor.close() 被隐式调用, 然后 waits 99 | ``` 100 | 101 | 3.使用`ThreadFactory`创建虚拟线程： 102 | 103 | 开发者还可以创建一个生成虚拟线程的工厂来管理，具体看下面的例子例子： 104 | 105 | ```java 106 | ThreadFactory virtualThreadFactory = Thread.ofVirtual() 107 | .name("virtual-thread", 0) 108 | .factory(); 109 | 110 | Thread factoryThread = virtualThreadFactory.newThread(() -> { 111 | // 由虚拟线程执行的代码 112 | }); 113 | factoryThread.start(); 114 | ``` 115 | 116 | 这段代码创建了一个虚拟线程工厂，每个虚拟线程都会以`virtual-thread`为前缀、以数字结尾（从0开始累加）的名称。 117 | 118 | ## 虚拟线程如何工作 119 | 120 | 虚拟线程是一个新的轻量级`java.lang.Thread`变体，由JVM的[Project Loom](https://openjdk.org/projects/loom/)项目实现的。 121 | 它使用了一种称为`Continuation`的技术，不受操作系统的管理或调度。相反，JVM负责调度。 122 | 123 |  124 | 125 | 应用程序实例化虚拟线程，而 JVM 分配计算资源来处理它们。 126 | 与传统线程相对比，传统线程直接映射到操作系统（OS）进程。 127 | 传统线程中，应用程序代码负责提供和释放 OS 资源。 128 | 而虚拟线程中，应用程序实例化虚拟线程，从而表达并发需求。 129 | 但实际上是 JVM 从操作系统获取并释放资源。 130 | 131 |  132 | 133 | 所需的平台线程在 FIFO 工作窃取 134 | [ForkJoinPool](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/concurrent/ForkJoinPool.html) 135 | 中进行管理，默认情况下使用所有可用处理器， 136 | 但可以通过调整系统属性 `jdk.virtualThreadScheduler.parallelism` 来根据您的需求进行修改。 137 | 您熟悉的 `ForkJoinPool` 和其他功能（如并行流）使用的公共池的主要区别在于，公共池以 LIFO 模式运行。 138 | 139 | -------------------------------------------------------------------------------- /src/md/java-features/Java9/jep222-jshell.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Java 9 新特性：交互式编程环境JShell 3 | shortTitle: 4 | description: 5 | icon: 6 | cover: 7 | author: 流浪码客 8 | isOriginal: true 9 | sticky: false 10 | star: false 11 | date: 2023-12-21 12 | category: Java Features 13 | tag: 14 | - java 15 | order: 222 16 | --- 17 | 18 | # Java 9 新特性：交互式编程环境JShell 19 | 20 | JShell 是 Java 9 引入的一个**交互式编程环境**，它是 Java 编程语言的 REPL（Read-Eval-Print Loop）实现。 21 | REPL 是一种编程环境，允许用户输入表达式并立即看到结果，而无需事先编写和编译完整的程序。 22 | JShell 的目标是提供一个轻量级、灵活且易于使用的工具，使得 Java 开发者能够更直观地编写和测试代码。 23 | 24 | ## JShell快速入门 25 | 26 | ### 启动JShell 27 | 28 | 打开终端，然后执行命令：`jshell`，执行效果如下： 29 | 30 | ```java 31 | ➜ ~ jshell 32 | | 欢迎使用 JShell -- 版本 9 33 | | 要大致了解该版本, 请键入: /help intro 34 | 35 | jshell> 36 | ``` 37 | 38 | ### 帮助介绍 /help intro 39 | 40 | 执行 `/help intro` 命令以获取有关 JShell 工具的简要介绍，**intro** 是主题，提供了关于 jshell 工具的核心概念和使用方法的信息。 41 | 42 | ``` 43 | jshell> /help intro 44 | | 45 | | intro 46 | | ===== 47 | | 48 | | 使用 jshell 工具可以执行 Java 代码，从而立即获取结果。 49 | | 您可以输入 Java 定义（变量、方法、类等等），例如：int x = 8 50 | | 或 Java 表达式，例如：x + x 51 | | 或 Java 语句或导入。 52 | | 这些小块的 Java 代码称为“片段”。 53 | | 54 | | 这些 jshell 工具命令还可以让您了解和 55 | | 控制您正在执行的操作，例如：/list 56 | | 57 | | 有关命令的列表，请执行：/help 58 | 59 | jshell> 60 | ``` 61 | 62 | ### 定义变量、方法、类 63 | 64 | ```java 65 | // 定义变量 66 | jshell> int x = 8 67 | x ==> 8 68 | 69 | // 定义方法 70 | jshell> int square(int num) { 71 | ...> return num * num; 72 | ...> } 73 | | 已创建 方法 square(int) 74 | 75 | // 定义类 76 | jshell> public class Message{ 77 | ...> private String msg; 78 | ...> public Message(String msg){ 79 | ...> this.msg = msg; 80 | ...> } 81 | ...> public String getMessage(){ 82 | ...> return msg; 83 | ...> } 84 | ...> } 85 | | 已创建 类 Message 86 | 87 | jshell> 88 | ``` 89 | 90 | ### 执行表达式、调用方法 91 | 92 | ```java 93 | // 执行 Java 表达式 94 | jshell> x + x 95 | $4 ==> 16 96 | 97 | // 调用方法 98 | jshell> square(5) 99 | $5 ==> 25 100 | 101 | 102 | // 创建类实例并调用方法 103 | jshell> Message messageObj = new Message("Hello, JShell!"); 104 | messageObj ==> Message@6d4b1c02 105 | 106 | jshell> messageObj.getMessage() 107 | 108 | $7 ==> "Hello, JShell!" 109 | ``` 110 | 111 | ## 查看定义的变量：/vars 112 | 113 | ```java 114 | jshell> /vars 115 | | int x = 8 116 | | int $4 = 16 117 | | int $5 = 25 118 | | Message messageObj = Message@6d4b1c02 119 | | String $7 = "Hello, JShell!" 120 | ``` 121 | 122 | ## 查看定义的方法：/methods 123 | 124 | ```java 125 | jshell> /methods 126 | | int square(int) 127 | ``` 128 | 129 | ## 查看定义的类：/types 130 | 131 | ```java 132 | jshell> /types 133 | | class Message 134 | 135 | ``` 136 | 137 | ## 列出输入源条目：/list 138 | 139 | 执行后，可以看到之前在`jshell`中输入的内容清单： 140 | 141 | ```java 142 | jshell> /list 143 | 144 | 1 : int x = 8; 145 | 2 : int square(int num) { 146 | return num * num; 147 | } 148 | 3 : public class Message{ 149 | private String msg; 150 | public Message(String msg){ 151 | this.msg = msg; 152 | } 153 | public String getMessage(){ 154 | return msg; 155 | } 156 | } 157 | 4 : x + x 158 | 5 : square(5) 159 | 6 : Message messageObj = new Message("Hello, JShell!"); 160 | 7 : messageObj.getMessage() 161 | 162 | jshell> 163 | ``` 164 | 165 | ## 编辑源条目：/edit 166 | 167 | 上面通过`/list`列出了输入的条目信息，下面试试通过`/edit`编辑下，比如： 168 | 169 | ```java 170 | jshell> /edit 2 171 | ``` 172 | 173 | 这将打开编辑器，修改先前定义的 `square` 方法。 174 | 175 | 修改完成后，点击 **accept** 即可 176 | 177 | ## 删除源条目：/drop 178 | 179 | 使用 `/drop` 命令可以删除之前输入的源代码块。可以通过指定**名称**或 **ID** 删除特定的源代码块。例如： 180 | 181 | ```java 182 | jshell> /drop Message 183 | | 已删除 类 Message 184 | ``` 185 | 186 | 这将删除之前定义的 `Message` 类。 187 | 188 | ## 保存文件：/save 189 | 190 | 通过 `/save` 命令，您可以将 JShell 中的源代码保存到文件中，以便将其保留或与他人共享。例如： 191 | 192 | ```java 193 | jshell> /save myCode.java 194 | ``` 195 | 196 | 这将把当前所有的源代码保存到一个名为 `myCode.java` 的文件中。 197 | 198 | ## 打开文件：/open 199 | 200 | 使用 `/open` 命令可以将文件的内容导入到 JShell 中，以便重新使用或修改。例如： 201 | 202 | ```java 203 | jshell> /open myCode.java 204 | ``` 205 | 206 | 这将导入之前保存的 `myCode.java` 文件中的源代码。 207 | 208 | ## 重置jshell：/reset 209 | 210 | 使用 `/reset` 命令可以清空 JShell 的状态，包括所有定义的变量、方法和类。例如： 211 | 212 | ```java 213 | jshell> /reset 214 | | 正在重置状态 215 | ``` 216 | 217 | 这将重置 JShell 并清除所有之前定义的内容。 218 | 219 | ## 查看引入的包：/imports 220 | 221 | 使用 `/imports` 命令可以查看当前已经导入的包。这对于确保您在 JShell 中能够访问所需的类和方法非常有用。例如： 222 | 223 | ```java 224 | jshell> /imports 225 | | import java.util.* 226 | ``` 227 | 228 | 这表明已经导入了 `java.util` 包。 229 | 230 | ## 退出jshell：/exit 231 | 232 | 使用 `/exit` 命令可以退出 JShell。如果需要，在命令后可以添加一个整数表达式片段作为退出代码。例如： 233 | 234 | ```java 235 | jshell> /exit 0 236 | ``` 237 | 238 | 这将以退出代码 0 退出 JShell。 239 | 240 | ## 查看命令：/help 241 | 242 | 最后，使用 `/help` 命令可以随时查看 JShell 的帮助信息，了解各种命令和主题的使用方法。例如： 243 | 244 | ```java 245 | jshell> /help 246 | | 键入 Java 语言表达式, 语句或声明。 247 | | 或者键入以下命令之一: 248 | | /list [<名称或 id>|-all|-start] 249 | | 列出您键入的源 250 | | /edit <名称或 id> 251 | | 编辑源条目 252 | | /drop <名称或 id> 253 | | 删除源条目 254 | | /save [-all|-history|-start] <文件> 255 | | 将片段源保存到文件 256 | | /open
98 |
99 | ### 连接（Linking）
100 |
101 | 分为三个阶段：
102 |
103 | * **验证**（Verify）：确保字节码符合虚拟机要求
104 | * **准备**（Prepare）：为字段赋予初始值
105 | * **解析**（Resolve）：符号引用转换为直接引用
106 |
107 | > **验证**（Verify）是连接阶段的第一阶段，目的是确保字节码的正确性和安全性，包括文件格式验证、元数据验证、字节码验证和符号引用验证四个阶段。
108 |
109 | 验证阶段大致上会完成下面四个阶段的检验动作：
110 |
111 | 1. **文件格式验证：** 检查字节流是否符合Class文件的格式规范。
112 | 2. **元数据验证：** 对类的元数据信息进行语义校验，确保其符合Java语言的语法和语意规则。
113 | 3. **字节码验证：** 通过数据流分析和控制流分析，确保字节码指令的合法性和逻辑正确性。
114 | 4. **符号引用验证：** 在解析阶段之前，检查符号引用是否能被正确解析。
115 |
116 | 
117 |
118 | > **准备**（Prepare）阶段为类中的静态变量分配内存并设置初始值。
119 |
120 | 静态变量的内存分配发生在**方法区**中。
121 |
122 | * 在 JDK 7及之前，HotSpot使用**永久代**（PerGen）来实现方法区，存放在堆内存中。
123 | * 在 JDK 8及之后，永久代被移除，取而代之的是**元空间**（Metaspace），存放在操作系统本地内存中。
124 |
125 | 
126 |
127 | > **解析**（Prepare）阶段是Java虚拟机将常量池内的符号引用替换为直接引用的过程。
128 |
129 | * **符号引用（Symbolic References）：** 字符串形式表示的对目标的逻辑引用
130 | * **直接引用（Direct References）：** 是直接定位到目标内存位置的指针、偏移量或句柄。
131 |
132 | 解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符这 7 类符号引用进行。
133 |
134 | ### 初始化（Initialization）
135 |
136 | > 类加载过程的最后一个阶段，负责执行类构造器方法 `不执行自动装配。开发者需要使用`ref`标签显式声明依赖关系。 | 33 | | byName | **按名称自动装配**：
容器会寻找一个属性名称或setter方法名称相匹配的Bean定义将其注入。
例如：Bean的属性名为`master`（也就是说，它有一个`setMaster(..)`方法），Spring会寻找名为`master`的Bean定义来注入。 | 34 | | byType | **按类型自动装配**：
容器会寻找与属性类型相匹配的Bean定义将其注入。如果存在多个相同类型的Bean，将抛出异常。 | 35 | | constructor | **按构造函数参数类型自动装配**：
容器会寻找与构造函数参数类型相匹配的Bean定义将其注入。如果没有匹配的Bean定义，将抛出异常。这种模式确保了Bean在创建时其必需的依赖就已经被满足。 | 36 | 37 | 利用`byType`或`constructor`自动装配模式，你可以装配数组（`array`）和泛型集合（`collection`）。 38 | 在这种模式下，Spring容器会自动寻找所有与所需类型相匹配的Bean，并将其注入到定义的数组或集合中，从而满足配置的依赖关系。 39 | 此外，当预期的键（key）类型为`String`时，还可以自动装配一个强类型化的`Map`实例。 40 | 在这个`Map`中，键（key）将是Bean的名称，而值（value）则是所有匹配期望类型的Bean实例。 41 | 42 | > 这样的自动装配`Map`实例，为我们提供了一种便捷的方式来管理和访问一组具有相同类型的Bean，特别是当我们需要根据名称快速查找特定的Bean时。 43 | 44 | ## 自动装配的局限和缺点 45 | 46 | 自动装配在项目中保持一致性时效果最佳。如果自动装配没有被普遍采用，而只有少数Bean定义使用它，可能会引起开发人员的困惑。 47 | 以下是考虑自动装配时需要注意的限制和缺点： 48 | 49 | 1. **显式依赖优先**：当存在显式依赖（`property`或`constructor-arg`）时，自动装配将被忽略 50 | 2. **不适用于基本类型**：自动装配不适用于基本类型，如`int`、`long`、`String`等，因为它们没有Bean名称 51 | 3. **精确性问题**：自动装配不如显式注入精确，因为它依赖于类型匹配，而不是Bean的名称或其他限定符，这可能导致意外的结果 52 | 4. **文档化缺失**：自动装配的依赖关系可能不会自动包含在生成的文档中，因此开发者需要额外的文档或注释来解释Bean之间的依赖关系 53 | 5. **多重匹配问题**：当存在多个Bean定义与自动装配的属性类型匹配时，Spring将抛出异常 54 | 6. **歧义性**：当存在多个Bean定义与自动装配的属性类型匹配时，Spring将无法确定哪个Bean是首选的,就会抛出异常 55 | 56 | 你有以下几种方法来解决**多重匹配问题和歧义性**： 57 | 58 | * 放弃自动装配，使用显式装配 59 | * 通过将Bean定义的`autowire-candidate`属性设置为`false`来排除Bean 60 | * 通过将Bean定义的`primary`属性设置为`true`来指定首选Bean 61 | * 实现更细粒度的控制，可以使用基于注解的配置方式， 62 | 参阅 [基于注解的容器配置](https://docs.spring.io/spring-framework/reference/core/beans/annotation-config.html) 63 | 64 | ## 从自动装配中排除Bean 65 | 66 | 在每个Bean定义中，你可以设置`autowire-candidate`属性来控制Bean是否标记为自动装配候选项。 67 | 68 | * 默认情况下，`autowire-candidate`属性的值为`true`，表示Bean是自动装配的候选项 69 | * 属性为`false`时，Bean将被排除在自动装配之外，这一设置对注解式配置 70 | （如[@Autowired](https://docs.spring.io/spring-framework/reference/core/beans/annotation-config/autowired.html)）同样有效 71 | 72 | ::: note 73 | **注意⚠️**：`autowire-candidate`属性仅影响基于类型的自动装配模式。 74 | 对于按名称的显示引用，`autowire-candidate`属性不起作用。 只要名称匹配，它仍然可以被注入。 75 | ::: 76 | 77 | 你还可以根据`byName`的模式匹配来限制自动装配候选项。 78 | 顶层的`
115 |
116 |
117 |
118 |
119 |