一、语言定位与核心理念差异
1.1 C++:系统级编程的“瑞士军刀”
C++由Bjarne Stroustrup于1983年在C语言基础上引入类机制而诞生,其设计哲学是“零开销抽象”——即抽象机制不应带来额外运行时开销。它支持过程式、面向对象、泛型及部分函数式编程范式,是少数能同时实现“底层硬件控制”与“上层系统建模”的通用语言。C++标准委员会在2011年(C++11)后开启现代化进程,后续C++14、C++17、C++20持续引入移动语义、lambda表达式、概念模板、协程等特性,使其在保持高性能的同时大幅降低开发复杂度。
在嵌入式、操作系统、游戏引擎、高频交易系统等对资源极度敏感的领域,C++仍是不可替代的选择。例如Unreal Engine 5、MySQL数据库核心、Chrome浏览器V8引擎均采用C++实现。值得注意的是,C++的“自由度”也意味着责任——开发者需手动管理内存、处理指针安全、规避未定义行为,这使其学习曲线陡峭,但一旦掌握,将获得对计算机底层的深度掌控力。
1.2 C#:微软生态的“现代Java”
C#由Anders Hejlsberg主导开发,首版于2000年随.NET Framework 1.0发布,定位为“面向组件的现代编程语言”,旨在融合Visual Basic的易用性与C++的性能。其核心优势在于深度集成Windows平台与Microsoft生态,通过CLR(Common Language Runtime)提供自动内存管理、类型安全、跨语言互操作等运行时服务。C#在2005年(C# 2.0)引入泛型,2007年(3.0)集成LINQ(语言集成查询),2015年(C# 6.0)全面拥抱异步编程(async/await),2020年(C# 9.0)支持记录类型(record)与顶层语句,逐步演进为兼具声明式与响应式编程能力的现代化语言。
当前C#已广泛应用于企业级应用、Unity游戏开发(占全球移动游戏开发的68%)、桌面应用(WPF/WinForms)、云服务(Azure Functions)等领域。其与Visual Studio IDE的深度绑定极大提升了开发效率,而.NET 5+的跨平台能力(Windows/macOS/Linux)进一步拓展了其适用边界。对于希望快速构建Windows原生应用或游戏的开发者而言,C#提供了最平滑的入门路径与最完善的工具链支持。
1.3 Java:企业级开发的“标准答案”
Java由James Gosling于1995年发布,其核心理念“一次编写,到处运行(Write Once, Run Anywhere)”通过JVM(Java Virtual Machine)实现——字节码在JVM上被解释或JIT编译为机器码。这一设计使Java成为首个真正实现跨平台的主流语言,尤其在互联网早期(1998-2005年)推动了Web应用服务器(如WebLogic、WebSphere)的普及。Java在2004年(Java 5)引入泛型、枚举、自动装箱等特性,2014年(Java 8)集成Lambda表达式与Stream API,2017年(Java 9)引入模块化系统(JPMS),持续保持技术先进性。
Java在金融、电信、政府等对稳定性要求极高的领域占据绝对主导地位。例如Android早期(2014年前)的原生开发、Spring生态(Spring Boot占Java Web开发的82%)、Hadoop大数据框架、Oracle数据库中间件均基于Java构建。其强类型系统、丰富的标准库(java.*包)、成熟的构建工具(Maven/Gradle)以及庞大的社区生态,使其成为企业级应用开发的首选语言。值得注意的是,Java 17(2021年)成为长期支持(LTS)版本,而Java 21(2023年)引入虚拟线程(Project Loom)进一步提升高并发场景下的吞吐量。
二、语言发展时间轴与关键里程碑
C++诞生:Stroustrup在贝尔实验室添加“类”到C语言,命名为“C with Classes”
Java项目启动:Green Team(James Gosling等)开发Oak语言,目标为嵌入式设备
Java正式发布:Sun Microsystems在SunWorld大会上宣布Oak更名为Java
C++标准委员会发布ISO/IEC 14882:1998,即C++98标准
C# 1.0随.NET Framework 1.0发布:微软对抗Java的“企业级反击”
C# 2.0引入泛型;Java 5.0引入泛型、枚举、注解;C++03标准发布
C++11发布:引入auto、lambda、智能指针、右值引用等现代特性
Java 8引入Lambda表达式与Stream API;C# 6.0支持字符串插值、异常筛选
C# 7.0支持元组(tuple)、本地函数、模式匹配;Java 9引入模块化系统
C# 9.0引入记录类型(record)与顶层语句;Java 16(LTS)默认启用JEP 395(模式匹配增强)
Java 19引入结构化并发(Incubator);C# 11支持UTF-8字符串字面量与列表模式
三、核心特性深度对比
性能维度对比
| 测试项目 | C++ | C# | Java |
|---|---|---|---|
| 编译型语言 | ✓ 直接生成机器码 | ✗ JIT编译(运行时) | ✗ JIT编译(运行时) |
| 内存管理开销 | 0(手动管理) | 中(GC暂停) | 中-高(GC暂停) |
| 数组访问速度 | 1.0×(基准) | 1.2×(需边界检查) | 1.3×(需边界检查+类型检查) |
| 数值计算(浮点) | 1.0× | 1.5×(JIT优化后) | 1.7×(HotSpot优化) |
| 启动时间(ms) | 1-5(无依赖) | 200-500 | 500-2000 |
注:测试环境为Intel Core i7-12700H/32GB RAM,Ubuntu 22.04。C++使用g++ -O3,C#使用.NET 7(Release模式),Java使用OpenJDK 17。性能数据基于SPEC CPU2017基准测试的归一化结果,数值越小表示越快。
并发模型对比
C++:依赖标准库(std::thread, std::async)与第三方库(如Boost.Asio)。C++20引入协程(coroutine)支持异步编程,但需手动管理线程安全与资源同步。典型用法:使用std::atomic实现无锁编程,或通过std::mutex保护共享数据。缺点是易出错(如死锁、数据竞争),适合对延迟极度敏感的场景(如高频交易)。
// C++17:使用std::async异步执行 #include#include int compute(int x) { return x * x + 2 * x + 1; } int main() { auto future = std::async(std::launch::async, compute, 5); std::cout << "Result: " << future.get() << std::endl; }
C#:以async/await为核心构建异步编程模型(APM),通过Task并行库(TPL)统一同步/异步操作。C# 8.0引入IAsyncEnumerable支持异步流,C# 9.0的top-level statements简化入口。优势在于语法简洁、错误处理统一(try/catch作用域清晰),适合构建高吞吐Web服务。
// C# 10:异步流示例
await foreach (var item in GetItemsAsync())
{
await ProcessAsync(item);
}
async IAsyncEnumerable<int> GetItemsAsync()
{
for (int i = 0; i < 10; i++)
{
await Task.Delay(100);
yield return i;
}
}
Java:早期使用线程池(ExecutorService)与Future,Java 8引入CompletableFuture,Java 21(LTS)通过Project Loom虚拟线程实现轻量级协程。虚拟线程(virtual thread)基于Fiber模型,单个JVM可轻松创建百万级线程,显著降低高并发场景下的资源消耗。Spring Framework 6全面拥抱虚拟线程,提升响应式Web应用的吞吐量。
// Java 21:虚拟线程示例
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 1000; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " on " + Thread.currentThread());
return taskId;
});
}
}
类型系统深度对比
| 特性 | C++ | C# | Java |
|---|---|---|---|
| 静态/动态 | 静态 | 静态 | 静态 |
| 泛型实现 | 编译期(模板实例化) | 运行期(类型擦除+box/unbox) | 运行期(类型擦除) |
| 泛型约束 | ✓(concept C++20) | ✓(where子句) | ✗(仅extends) |
| 模式匹配 | ✓(C++23) | ✓(递归模式 C# 8) | ✓(switch表达式 Java 17) |
| 空值安全 | ✗(需手动检查) | ✓(可空引用类型 C# 8) | ✓(@NonNull注解) |
C++的模板(template)是编译期机制,生成特定类型的代码副本,零运行时开销,但可能导致代码膨胀(code bloat)。C# 8.0引入可空引用类型(? T),通过编译器警告强制处理null场景,大幅降低空指针异常风险。Java 8的Optional类提供空值包装,但需手动调用orElse/orElseThrow,使用成本较高。现代C++(C++20)的concept特性类似C#的泛型约束,允许在编译期验证模板参数的合法操作集,提升代码健壮性。
生态系统成熟度
C++:包管理工具分散(Conan、vcpkg、Hunter),缺乏统一标准。构建系统复杂(CMake需维护大量CMakeLists.txt),跨平台编译门槛高。优势在于底层库丰富(Boost、STL、Eigen),但新开发者需投入大量时间配置环境。
C#:NuGet包管理器集成度高,Visual Studio提供一站式开发体验(编辑/调试/测试/部署)。.NET 6+支持AOT编译(Ahead-of-Time),生成独立可执行文件(如dotnet publish -r win-x64 --self-contained),简化部署流程。Unity的Asset Store提供超2万款插件,加速游戏开发。
Java:Maven/Gradle标准化构建流程,Spring Boot提供“约定优于配置”理念,大幅减少样板代码。JDK自带JFR(Java Flight Recorder)与JMC(Java Mission Control)实现运行时诊断,企业级可观测性完善。缺点是微服务部署包体积大(典型Spring Boot应用>50MB),冷启动慢。
四、语法差异实证对比
4.1 Hello World与变量声明
| 语言 | 代码示例 |
|---|---|
| C++ |
#include |
| C# |
using System;
class Program {
static void Main() {
Console.WriteLine("Hello, World!");
int x = 42;
var y = 3.14; // 推导类型
}
}
|
| Java |
public class Main {
public static void main(String[] args) {
System.out.println("Hello, World!");
int x = 42;
var y = 3.14; // Java 10+支持
}
}
|
关键差异:C++需显式包含头文件(#include),C#使用命名空间(using),Java通过import引入类。C++的auto在编译期推导,C#与Java的var在声明时推导(Java需显式启用--release 10)。
4.2 面向对象核心特性
| 特性 | C++实现 | C#实现 | Java实现 |
|---|---|---|---|
| 类定义 |
class Person {
private:
std::string name;
public:
Person(std::string n) : name(n) {}
virtual void speak() {
std::cout << "Hello, I'm " << name;
}
};
|
class Person {
private string name;
public Person(string n) => name = n;
public virtual void Speak() {
Console.WriteLine($"Hello, I'm {name}");
}
}
|
class Person {
private String name;
public Person(String n) { name = n; }
public void speak() {
System.out.println("Hello, I'm " + name);
}
}
|
| 接口 | ✗(需抽象类模拟) | ✓(interface) | ✓(interface) |
| 多重继承 | ✓(类继承+接口) | ✗(类单继承+多接口) | ✗(类单继承+多接口) |
C++支持多重继承(类与接口混合),但易引发菱形继承问题;C#与Java采用单继承+多接口模型,通过组合(composition)规避复杂性。C#的接口支持默认实现(default interface methods),Java 8起亦支持(需default关键字),使接口可提供部分实现逻辑。
4.3 泛型/模板对比
C++模板(C++20 concept):在编译期生成代码,支持任意类型操作,但错误信息冗长(template instantiation depth exceeded)。例如:
templateconcept Numeric = std::is_arithmetic_v ; template T add(T a, T b) { return a + b; } // 编译错误示例(调用add("hi", "world")) // error: cannot use concept constraint 'Numeric' // with 'const char*' (not arithmetic)
C#泛型(类型擦除+box/unbox):运行时保留类型信息,但值类型需装箱/拆箱。例如:
public class Box<T> where T : struct // 约束为值类型
{
public T Value { get; set; }
public Box(T value) => Value = value;
}
var box = new Box(42); // 无装箱(T=int)
var box2 = new Box<object>(42); // 值类型装箱
Java泛型(完全类型擦除):运行时无法获取泛型类型,需通过反射或传递Class对象。例如:
public class Box<T> {
private T value;
public Box(T value) { this.value = value; }
public T getValue() { return value; }
}
// 类型擦除后等价于:
// public class Box {
// private Object value;
// public Object getValue() { return value; }
// }
Box box = new Box<>(42);
Integer val = box.getValue(); // 编译器自动插入类型转换
五、内存管理机制对比
5.1 C++:手动管理与智能指针
C++内存分为栈(stack)与堆(heap):栈变量随作用域自动释放,堆内存需手动new/delete。C++11引入智能指针:std::unique_ptr(独占所有权)、std::shared_ptr(引用计数)、std::weak_ptr(解决循环引用)。例如:
#includeclass Resource { public: ~Resource() { std::cout << "Destroyed"; } }; int main() { // unique_ptr:自动释放 auto ptr1 = std::make_unique (); // shared_ptr:引用计数 auto ptr2 = std::make_shared (); auto ptr3 = ptr2; // 引用+1 // weak_ptr:不增加引用计数 std::weak_ptr weak = ptr2; } // 输出:Destroyed(ptr1析构时) // Destroyed(ptr2/ptr3析构时)
关键优势:零开销抽象;风险:悬空指针、内存泄漏(如忘记delete)、重复释放。建议遵循RAII(Resource Acquisition Is Initialization)原则,将资源生命周期与对象绑定。
5.2 C#与Java:垃圾回收(GC)机制
C# GC(.NET 7):分代回收(Gen0/Gen1/Gen2),工作线程(worker threads)并行清理。支持后台GC(background GC)减少暂停时间。使用finally块或using语句释放非托管资源(如文件句柄):
using (var file = File.OpenRead("data.txt")) {
// 使用文件流
} // 自动调用Dispose()
Java GC(OpenJDK 17):默认使用G1(Garbage-First)收集器,目标是暂停时间<200ms。支持ZGC(低延迟GC)与Shenandoah(并发压缩)。通过try-with-resources释放资源:
try (var reader = new BufferedReader(...)) {
// 使用reader
} // 自动关闭资源
性能对比:C++手动管理延迟更低(微秒级),但开发成本高;C#/Java GC暂停时间在毫秒级,适合对吞吐量要求高、可容忍短暂停顿的场景。
六、开发工具与生态体系
6.1 集成开发环境(IDE)
| 语言 | 主流IDE | 核心优势 |
|---|---|---|
| C++ | Visual Studio(Windows)、CLion(跨平台)、Qt Creator | 强大的调试器(支持内联汇编)、智能感知、性能分析器 |
| C# | Visual Studio(Windows/macOS)、JetBrains Rider | 深度集成.NET调试器、XAML设计器、单元测试工具 |
| Java | IntelliJ IDEA、Eclipse、NetBeans | 智能重构、Spring Boot支持、远程调试、JProfiler集成 |
Visual Studio系列(VS/VS Code)对C#支持最完善;IntelliJ IDEA在Java生态中占据78%份额(2023年Stack Overflow调查);CLion采用JetBrains引擎,但C++编译器配置较复杂。
6.2 包管理与构建工具
| 语言 | 包管理器 | 构建工具 |
|---|---|---|
| C++ | Conan(最流行)、vcpkg(微软支持)、Hunter | CMake(事实标准)、Bazel、Ninja |
| C# | NuGet(集成于VS) | MSBuild(.NET CLI)、Cake |
| Java | Maven Central(最大仓库)、Gradle Plugin Portal | Maven(XML配置)、Gradle(Kotlin DSL) |
C++包管理碎片化严重,Conan支持二进制包分发与依赖解析;NuGet通过.nuspec文件定义包元数据;Maven使用pom.xml管理依赖,Gradle通过build.gradle(Kotlin)实现声明式构建。
6.3 云原生与容器支持
C++:需静态链接依赖,生成大体积二进制文件。常用方案:使用Docker多阶段构建,将构建环境与运行环境分离。例如:
# Dockerfile FROM ubuntu:22.04 AS build RUN apt-get update && apt-get install -y g++ COPY . /src WORKDIR /src RUN g++ -O3 -static -o app main.cpp FROM scratch COPY --from=build /src/app /app ENTRYPOINT ["/app"]
C#:.NET 6+支持Linux容器,可生成单文件部署包。示例:
dotnet publish -c Release -r linux-x64 --self-contained true \
--p:PublishSingleFile=true
Java:通过JLink生成精简JRE,结合Docker slim镜像优化体积。Spring Boot 3支持GraalVM原生镜像,启动时间<100ms。
七、典型应用场景与选型指南
游戏开发领域
| 平台 | 主流语言 | 代表引擎/框架 | 理由 |
|---|---|---|---|
| PC/主机 | C++ | Unreal Engine 5、CryEngine | 极致性能、DirectX/Vulkan底层控制 |
| 跨平台(独立游戏) | C# | Unity(全球38%手游采用) | 快速迭代、跨平台(iOS/Android/PC) |
| Web游戏 | JavaScript | Phaser、Babylon.js | 浏览器原生支持 |
| 移动端 | C#(Unity)、Java/Kotlin(Android) | Unity、Godot(C#后端) | 开发效率高、资源占用低 |
Unity使用C#作为脚本语言,通过IL2CPP可将C#转为C++提升性能(iOS平台强制要求)。Unreal Engine 5的蓝图系统底层仍基于C++,高级逻辑可混合C++与蓝图开发。
企业级应用
| 场景 | 推荐语言 | 技术栈示例 |
|---|---|---|
| 银行核心系统 | Java | Spring Boot + Hibernate + Oracle |
| 政府OA系统 | C# | .NET 6 + Entity Framework + SQL Server |
| 高频交易系统 | C++ | STL + Boost.Asio + 自定义协议栈 |
| 微服务网关 | C# | ASP.NET Core + Kubernetes + Istio |
Java在金融领域占比62%(2023年IDC报告),得益于其稳定性与JVM生态;C#在Windows Server环境部署成本低,与Active Directory深度集成;C++在需要亚毫秒级延迟的场景(如股票撮合引擎)无可替代。
移动端开发
iOS:原生开发使用Swift/Objective-C,但可通过Xamarin(C#)或React Native(JS)跨平台。Unity游戏占iOS游戏市场的45%(2023年数据)。
Android:Java(历史原因)与Kotlin(Google官方推荐)并存。C#通过Xamarin.Forms可构建跨平台应用,但体积大(>15MB)。主流方案:Android原生(Kotlin) + iOS原生(Swift) + 共享业务逻辑(C#/.NET Standard)。
新兴趋势:Jetpack Compose(Android现代UI框架)与SwiftUI(iOS)推动原生开发体验升级,跨平台框架(Flutter/Dart)在UI一致性上更具优势。
嵌入式系统
C++是嵌入式开发首选(占83%份额),因其支持零开销抽象与精确内存控制。常用框架:mbed OS(ARM官方支持)、Zephyr(Linux基金会项目)。例如:
#include "mbed.h"
DigitalOut led1(LED1);
int main() {
while (true) {
led1 = !led1;
wait_ms(500);
}
}
C#在Windows IoT Core(树莓派)上有应用,但资源占用高(需256MB+ RAM)。Java在低端设备不适用,但Android系统基于Linux内核,其Java API(Android SDK)主导移动嵌入式市场。
八、决策树:根据需求选择语言
8.1 问题导向决策流程
8.2 学习曲线对比
| 维度 | C++ | C# | Java |
|---|---|---|---|
| 入门难度 | ★★★★★(指针/内存管理) | ★★★☆☆(自动GC简化) | ★★★☆☆(强类型但JVM抽象) |
| 进阶门槛 | ★★★★☆(模板元编程) | ★★★☆☆(LINQ/异步) | ★★★☆☆(JVM调优) |
| 生态复杂度 | ★★★★☆(工具链碎片化) | ★★☆☆☆(VS一体化) | ★★★☆☆(Maven/Gradle配置) |
| 就业市场 | 中(高薪岗位少) | 高(企业应用需求大) | 极高(Android/后端) |
新手建议:从C#或Java入门,掌握编程核心概念后,再根据方向选择C++深入底层。资深开发者应掌握至少两种语言,以应对不同项目需求。
九、学习资源推荐
9.1 书籍推荐
| 语言 | 经典书籍 | 特点 |
|---|---|---|
| C++ | 《Effective C++》(Scott Meyers) | 55个具体建议,覆盖C++11/14/17 |
| C++ | 《C++ Primer》(Lippman) | 系统性入门,含C++20内容 |
| C# | 《C# in Depth》(Jon Skeet) | 深入语言特性(LINQ/异步/模式匹配) |
| Java | 《Effective Java》(Joshua Bloch) | Java 8/9/10/11最佳实践 |
| Java | 《Java Concurrency in Practice》 | 并发编程圣经 |
9.2 在线资源
- C++:cppreference.com(官方文档)、Compiler Explorer(在线编译器)
- C#:Microsoft Learn(官方教程)、SharpLab(IL反编译)
- Java:Oracle Docs(官方文档)、Baeldung(实践教程)
- 通用:LeetCode(算法练习)、GitHub(开源项目参考)
十、网友最常问的10个问题
Q1:C++和Java哪个更适合初学者?
A:Java更友好。C++的指针、手动内存管理易导致新手崩溃(如内存泄漏、悬空指针),而Java的GC与强类型系统提供安全网。但若目标是游戏开发,建议从C#入门(Unity学习曲线更平缓)。
Q2:C#和Java在性能上谁更强?
A:C#略优。C#的JIT(RyuJIT)优化更激进(如SIMD指令支持),且.NET 6+的AOT编译可生成接近C++的性能。实测显示:C#在数值计算中比Java快10-15%(OpenJDK 17 vs .NET 7)。
Q3:C++的智能指针能完全替代手动管理吗?
A:不能。智能指针解决大部分场景,但仍有局限:
• 循环引用需用weak_ptr打破
• 多线程下shared_ptr引用计数非原子操作(需std::atomic)
• 高频分配/释放场景仍需自定义内存池
建议:优先使用unique_ptr,共享资源用shared_ptr+weak_ptr组合。
Q4:Java虚拟机如何实现跨平台?
A:通过字节码(bytecode)与JVM实现:
1. 源码→编译为平台无关的class文件(字节码)
2. JVM加载字节码→JIT编译为机器码
3. 不同OS有对应JVM(Windows JVM ≠ macOS JVM)
缺点:启动慢(需JIT预热)、内存占用高(典型JVM进程>500MB)。
Q5:C++20的协程比Java的虚拟线程更先进吗?
A:各有优势:
• C++20协程:零开销、编译期生成代码,适合底层高性能场景
• Java虚拟线程:运行时调度,百万级线程仅需1GB内存
关键区别:C++协程需手动管理栈帧,Java虚拟线程由JVM自动调度。
Q6:C#的record类型与Java的record有何异同?
A:均用于不可变数据载体,但实现细节不同:
C# record:
• 自动生成Equals/GetHashCode/ToString
• 支持with表达式(非破坏性修改)
Java record(Java 16):
• 仅生成getter/equals/hashCode
• 无with支持
• 更轻量,但功能受限
Q7:Java的泛型为什么用类型擦除?
A:为保持与Java 1.1的二进制兼容性。若使用具体化泛型(reified generics),需修改JVM指令集,导致所有旧类文件无法运行。Java选择运行时类型擦除+桥接方法(bridge method)实现兼容性,代价是无法获取泛型类型(如List
Q8:C++的模板元编程能做什么?
A:编译期计算,例如:
• 编译期斐波那契数列(constexpr函数)
• 类型 traits(std::is_integral
• 模板递归生成代码(如std::tuple)
但错误信息冗长(如template instantiation depth exceeded),C++20 concept可缓解此问题。
Q9:Java 21的虚拟线程如何提升性能?
A:虚拟线程是用户态线程(Fiber),由JVM调度而非OS:
• 创建成本≈1KB(OS线程≈1MB)
• 切换无需陷入内核
• 单JVM可轻松创建100万+线程
Spring Framework 6通过@Async默认启用虚拟线程,HTTP请求吞吐量提升5-10倍。
Q10:未来十年哪种语言会主导?
A:分场景:
• 底层系统:C++长期主导(无替代方案)
• 企业后端:Java(稳定性)与C#(微软生态)并存
• 游戏开发:C#(Unity)与C++(Unreal)互补
• 新兴领域:Rust可能在系统编程领域崛起,但Java/C#在生态惯性下仍将主导应用层。
十一、未来趋势与技术演进
11.1 C++:向现代化持续进化
C++23(2023年发布)引入:
• std::print(简化输出)
• 线程本地存储(thread_local)改进
• 协程支持增强
C++26(预期2026年)将聚焦:
• 模块化(module)彻底取代头文件
• 标准库重构(std::expected替代std::optional)
• 更强的并发原语(executors模型)
11.2 C#:深度集成AI与云原生
C# 12(2023年)新增:
• 空值类型参数(required修饰符)
• 列表模式(list patterns)
• 委托表达式(delegate expressions)
.NET 8(2023年)重点优化:
• AOT编译(支持Blazor WebAssembly)
• 热重载(Blazor开发时调试)
• AI集成(Microsoft.Extensions.AI包)
11.3 Java:构建下一代云原生应用
Java 21(2023年LTS)里程碑特性:
• 虚拟线程(Project Loom)
• 结构化并发(Incubator)
• 记录模式(record patterns)
Java 22(2024年3月发布):
• 非请求驱动I/O(Project Loom)
• 类型注解增强(@NonNullByDefault)
Spring Framework 6.1:全面支持虚拟线程,HTTP服务器吞吐量提升300%。