.NET 9中的异常处理性能提升分析：为什么过去慢，未来快

一、为什么要关注.NET异常处理的性能
随着现代云原生、高并发、分布式场景的大量普及，异常处理（Exception Handling）早已不再只是一个冷僻的代码路径。在高复杂度的微服务、网络服务、异步编程环境下，服务依赖的外部资源往往不可靠，偶发失效或小概率的“雪崩”场景已经十分常见。实际系统常常在高频率地抛出、传递、捕获异常，异常处理性能直接影响着系统的恢复速度、吞吐量，甚至是稳定性与容错边界。
.NET平台在异常处理性能方面长期落后于C++、Java等同类主流平台——业内社区多次对比公开跑分就证实了这一点，.NET 8时代虽然差距有所缩小，但在某些高并发/异步等极端场景下，异常高开销持续困扰社区和大厂工程师。于是到了.NET 9，终于迎来了一次代际变革式的性能飞跃，抛出/捕获异常的耗时基本追平C++，成为技术圈最关注的.NET runtime底层事件之一。
二、实测：.NET 9异常处理提速直观对比

1. 测试代码

最经典的异常性能测试如下——C# 和 Java的实现基本一致
C#:

1. class ExceptionPerformanceTest
2. {
3.     public void Test()
4.     {
5.         var stopwatch = Stopwatch.StartNew();
6.         ExceptionTest(100_000);
7.         stopwatch.Stop();
8.         Console.WriteLine(stopwatch.ElapsedMilliseconds);
9.     }
10.     private void ExceptionTest(long times)
11.     {
12.         for (int i = 0; i < times; i++)
13.         {
14.             try
15.             {
16.                 throw new Exception();
17.             }
18.             catch (Exception ex)
19.             {
20.                 // Ignore
21.             }
22.         }
23.     }
24. }

复制代码

Java:

1. public class ExceptionPerformanceTest {
2.     public void Test() {
3.         Instant start = Instant.now();
4.         ExceptionTest(100_000);
5.         Instant end = Instant.now();
6.         Duration duration = Duration.between(start, end);
7.         System.out.println(duration.toMillis());
8.     }
10.     private void ExceptionTest(long times) {
11.         for (int i = 0; i < times; i++) {
12.             try {
13.                 throw new Exception();
14.             } catch (Exception ex) {
15.                 // Ignore
16.             }
17.         }
18.     }
19. }

复制代码

2. 早期测试结果（以.NET Core 2.2时代为例）

• .NET: 2151ms
  
• Java: 175ms
  

.NET 的异常抛出/捕获速度相较慢得多。但到了.NET 8后期和.NET 9，基准成绩已翻天覆地：
3. 新时代基准结果（.NET 8 vs .NET 9）

借助 BenchmarkDotNet 可以更科学对比：

1. using BenchmarkDotNet.Attributes;
2. using BenchmarkDotNet.Columns;
3. using BenchmarkDotNet.Configs;
4. using BenchmarkDotNet.Jobs;
5. using BenchmarkDotNet.Reports;
6. using BenchmarkDotNet.Environments;
8. namespace ExceptionBenchmark
9. {
10.     [Config(typeof(Config))]
11.     [HideColumns(Column.Job, Column.RatioSD, Column.AllocRatio, Column.Gen0, Column.Gen1)]
12.     [MemoryDiagnoser]
13.     public class ExceptionBenchmark
14.     {
15.         private const int NumberOfIterations = 1000;
17.         [Benchmark]
18.         public void ThrowAndCatchException()
19.         {
20.             for (int i = 0; i < NumberOfIterations; i++)
21.             {
22.                 try
23.                 {
24.                     ThrowException();
25.                 }
26.                 catch
27.                 {
28.                     // Exception caught - the cost of this is what we're measuring
29.                 }
30.             }
31.         }
33.         private void ThrowException()
34.         {
35.             throw new System.Exception("This is a test exception.");
36.         }
38.         private class Config : ManualConfig
39.         {
40.             public Config()
41.             {
42.                 AddJob(Job.Default.WithId(".NET 8").WithRuntime(CoreRuntime.Core80).AsBaseline());
43.                 AddJob(Job.Default.WithId(".NET 9").WithRuntime(CoreRuntime.Core90));
45.                 SummaryStyle =
46.                     SummaryStyle.Default.WithRatioStyle(RatioStyle.Percentage);
47.             }
48.         }
49.     }
50. }

复制代码

如下图结果，抛出+捕获1000次异常：

• .NET 8：每次约 12μs
  
• .NET 9：每次减少至约 2.8μs （约76~80%提升）
  

.NET 9的性能提升几乎让EH成本降到C++/Java同量级，成为托管平台的性能标杆之一。
三、.NET早期异常处理为何如此之慢？

1. 策略层面的历史误区

传统观点认为：“异常只为异常流程准备，主业务应以if/else或TryXXX等方式避免极端异常分支”。社区和官方因此忽视了EH系统的极限性能，无论架构设计还是细节实现都欠缺优化，反映在：

• 内部优先保证兼容性和健壮性，而不是高性能
  
• 代码中凡是热路径，都让开发者“自觉避开异常”
  

近年来，现代服务常常：

• 依赖于“不可靠资源”  （如网络、外部API、云存储），短暂失效随时发生
  
• 借助基于async/await的异步编程，异常常常跨栈、跨线程重抛
  
• 在微服务系统中，单点故障可能导致“异常风暴”，大量请求因依赖故障极短时间内批量失败
  

这些场景下，异常处理已极易成为性能瓶颈，应用的可用性与SLA依赖于异常恢复速度。
2. CoreCLR/Mono 异常实现机制的先天劣势

Windows实现

• 采用Windows的Structured Exception Handling (SEH)，异常抛出后，OS内核统一回溯堆栈、查找/触发catch和finally，且需要“双遍遍历”栈帧（第一次查catch、第二次触发catch/finally，源数据由Windows维护）
  

  Structured Exception Handling（结构化异常处理，简称 SEH）是微软 Windows 操作系统上一种异常处理机制，主要用于捕获和处理程序运行过程中产生的异常，如访问违规（Access Violation）、除零错误、非法指令等。在 Windows 平台上，SEH 被底层编译器和系统广泛支持。
  

  
  
• 用户层主要通过回调介入，绝大多数性能消耗“锁死”在OS堆栈查找、回调和上下文切换中，优化空间很小
  

NameExc %ExcInc %Incntdll!RtlpxLookupFunctionTable11.44,52511.44,525ntdll!RtlpUnwindPrologue11.24,44111.24,441ntdll!RtlLookupFunctionEntry7.22,85728.411,271ntdll!RtlpxVirtualUnwind6.52,57917.77,020ntdll!RtlpLookupDynamicFunctionEntry3.61,4259.83,889coreclr!EEJitManager::JitCodeToMethodInfo2.91,1672.91,167ntdll!RtlVirtualUnwind2.91,13717.97,099ntoskrnl!EtwpWriteUserEvent2.59904.31,708coreclr!ExceptionTracker:rocessManagedCallFrame2.494118.77,405coreclr!ProcessCLRException2.493893.336,969ntdll!LdrpDispatchUserCallTarget2.28712.2871coreclr!ExecutionManager::FindCodeRangeWithLock2.28682.2868coreclr!memset2.07932.0793coreclr!ExceptionTracker:rocessOSExceptionNotification1.974231.912,622coreclr!SString::Replace1.87201.8720ntoskrnl!EtwpReserveTraceBuffer1.87181.8718coreclr!FillRegDisplay1.87091.8709ntdll!NtTraceEvent1.76737.12,803

Unix/Linux实现

• 没有SEH，只能自己模拟
  
• 采用C++异常，异常抛出后靠libgcc/libunwind的_C++机制回溯托管栈，但需“桥接”托管/本地的边界，异常对象需反复throw/catch，初始化/过滤时会有多次C++异常嵌套传递
  

  libunwind 是一个开源的栈回溯库，主要用于在运行时获取和操作调用栈，从而支持异常处理、调试和崩溃分析等功能。
  

  
  
• 托管运行时(如ExecutionManager)  需要频繁做函数表和异常元数据线性遍历（链表查找），并发场景下会有大量锁竞争，极易成为瓶颈
  

实际CPU性能热点采样发现：

• libgcc_s.so.1/_Unwind_Find_FDE等C++异常系统函数占用近13%的热点
  
• 托管代码层大量链表遍历/锁(ExecutionManager::FindCodeRangeWithLock等)
  
• 多线程/多异常场景下lock恶性竞争，栈查找速度极慢
  

OverheadShared ObjectSymbol+ 8,29%libgcc_s.so.1[.] _Unwind_Find_FDE+ 2,51%libc.so.6[.] __memmove_sse2_unaligned_erms+ 2,14%ld-linux-x86-64.so.2[.] _dl_find_object+ 1,94%libstdc++.so.6.0.30[.] __gxx_personality_v0+ 1,85%libgcc_s.so.1[.] 0x00000000000157eb+ 1,77%libc.so.6[.] __memset_sse2_unaligned_erms+ 1,36%ld-linux-x86-64.so.2[.] __tls_get_addr+ 1,28%libcoreclr.so[.] ExceptionTracker:rocessManagedCallFrame+ 1,26%libcoreclr.so[.] apply_reg_state+ 1,12%libcoreclr.so[.] OOPStackUnwinderAMD64::UnwindPrologue+ 1,08%libgcc_s.so.1[.] 0x0000000000016990+ 1,08%libcoreclr.so[.] ExceptionTracker:rocessOSExceptionNotification

额外开销

• 每次抛出异常需清空/复制完整CONTEXT结构（Windows上下文），单次就近1KB数据
  
• 捕获栈信息、生成调试辅助、捕获完整stacktrace等都增加明显延迟
  

3. Async/多线程场景放大性能损耗

现代C#的async/await广泛出现。每遇到await断点，异常需在async状态机多次catch/throw重入口，即使只有1层异常，实际走了多倍catch分支。多线程下，本地堆栈互不关联，所有栈回溯、元数据查找都需走OS或本地锁/链表，进一步拉低性能扩展性。
4. 跨平台和历史兼容包袱

因Windows/Unix两套机制并存，大量platform abstraction和边界容错逻辑，极大增加了维护成本和bug风险。每一次异常跨界都需要特殊处理，开发运维和调优都十分困难。
以下是.NET9以前多线程和单线程异常抛出耗时，可以看到随着堆栈深度的增加，抛出异常要花费的世界越来越长。

四、技术极客视角：.NET 9彻底变革的细节原理

.NET 9之所以实现了异常处理的性能“质变”，核心思路是吸收NativeAOT的极简托管实现，将主力流程自托管直接管理，核心只依赖native stack walker完成功能边界，避免一切反复嵌套或冗余环节。
（一）NativeAOT异常处理架构剖析

1. 设计变革

• 完全托管驱动主流程
  异常的捕获、catch分派、finally查找、异常对象/类型的元数据查找等主环节，全部写成托管代码（C#逻辑）。
  
• native code仅负责栈帧展开（stack walking）
  需要时才调用本地API（libunwind/Windows API）由native/cross平台实现stack frame的move next/遍历，极简无其他依赖。
  
• 无C++异常桥接，这样省去了_os-unwind、double catch-rethrow等所有历史冗余。
  
• 功能单纯、易于调优和定制，不到300行关键路径代码。
  

2. 优势分析

• 代码极简，热路径关键点完全可控
  
• 不存在异步场景下的“状态机分支回溯”性能急剧下滑
  
• 托管逻辑易于内联、缓存
  
• Native代码只做最小功能、极易换实现/裁剪
  
• 性能调优点固定且标志性突出（大部分耗时都在stack walker/元数据cache里）
  
• 兼容可扩展，后续想做特殊异常/自定义类型极为简便
  

3. 技术细节

• 异常对象的stacktrace/元数据在托管代码按需附加
  
• 若已知异常只在本地代码路径，完全可绕开“不需要的”full stacktrace/callstack/diagnostic等场景
  
• 可以整合cache优化，如将每个托管JIT帧的元数据查找结果放本地线程缓存（甚至开启pgo热点分支识别，见后续）。
  

（二）.NET 9实现与补全 —— 同步NativeAOT设计到CoreCLR

在.NET 9，团队把NativeAOT的异常处理模式移植到了CoreCLR上。主要技术变更包括：

• 将异常展开、catch/finally分派等环节全部搬到托管主流程
  
• native helper只做最小的stack frame展开，与垃圾回收栈遍历接口复用（易于维护）
  
• 强化托管级缓存与元数据管理。关键链表遍历全部升级成缓存/高速哈希表，一举解决了多线程、深栈、频繁异常场景下的scalability困境
  
• 钉死所有多余的C++ throw/catch——对Unix/Windows都生效
  
• 为Async/Await生成优化代码路径，避免多次重复抛出/捕获
  

工程落地与效果

• 性能测试实测，异常处理耗时降幅约76%~80%，多线程/高并发效果更好
  
• 性能剖析热点：主要耗时已缩小到stack walker和关键数据结构哈希效率上，其他已近极致
  
• 全平台统一，无历史特殊兼容路径、包袱
  

真实图片示例

• 单线程性能提升图：
  

• 多线程性能提升图：
  

（三）可进一步优化的场景与细节

• 热点分支profile（PGO）
  
  
  
  • 异常的“常用路径”可被profile，按pgo机制热路径内联/重编排逻辑
    
  • 比如async await状态机里常抛异常的分支inline获得最佳cache局部性
    
  
  
• Unwind Section缓存/优化
  
  
  
  • 比如在libunwind的findUnwindSections过程中用cache提升多线程吞吐，已实测可提速近7倍
    
  • 类似样板代码见：https://gist.github.com/filipnavara/9dca9d78bf2a768a9512afe9233d4cbe
    
  
  
• 双检省栈trace与细粒度采集
  
  
  
  • 支持仅按需采集stacktrace（避免捕获所有调试信息）
    
  
  
• 特殊场景快速捕获（业务异常/操作性异常）
  
  
  
  • 通过拓展托管catch块类型，可以极简分为业务异常与系统异常，实现“无栈捕获”，加速高频捕获型异常（如EndOfData、ParseError等流控制型异常）
    
  
  
• 异步异常统一延迟捕获传递
  
  
  
  • 在没有用户自定义try块的async方法中，捕获异常仅保存，真正抛出延迟到非异常主流程结束前即可。这将极大降低状态机驱动的抛出/捕获次数。
    
  
  

六、总结展望

.NET 9通过彻底拥抱NativeAOT极简式的托管异常处理体系，把历史包袱（OS-Specific/C++ Exception Bridge/冗余链表&锁/多次catch-rethrow）一举清除，大幅释放了异常路径的性能潜力。这一变革支撑了.NET在微服务、云原生、异步并发等新主流场景下的顶级运行时表现。未来，随着堆栈展开、元数据cache自适应等不断迭代，.NET有望成为托管平台的异常处理性能“天花板”。
附录与参考文献

• .NET Runtime Issue #77568: Exception handling performance
  
• .Net Exception performance vs JAVA
  
• Port NativeAOT exception handling to CoreCLR #88034
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！