JavaScript中匿名、命名函数的性能测试
转载 & & 投稿：junjie
这篇文章主要介绍了JavaScript中匿名、命名函数的性能测试,简单来讲匿名即没有名字的函数,它和命名函数相比性能如何呢,本文即是对它们性能的测试,需要的朋友可以参考下
我们经常通过匿名函数（Anonymous function）来写回调。
简单来讲匿名即没有名字的函数，一般都立即执行。但是它与命名函数（有名字的函数）的性能如何呢？
我们可以比较一下，我们随便找一台可以执行Shell命令的计算机来使用大量函数调用看一看二者执行消耗时间：
anonymous.js
var count =
& , sum&& = 0
while (count--) (function() { sum++ })()
$ time node anonymous.js
real&&& 0m1.456s
user&&& 0m0.015s
sys&&&& 0m0.031s
再来看看命名函数
var count =
& , sum&& = 0
var cb = function() {
while (count--) cb()
$ time node named.js
real&&& 0m0.575s
user&&& 0m0.000s
sys&&&& 0m0.046s
命名函数会快很多，为什么会这样呢？其实不难解释，匿名函数每次都需要重新解释回调，但是命名函数只需要解释一次，因此性能会有提升，但是测试发现这种提升是非常非常微小的，完全不必将非常顺手的一个回调单独写成另外一个变量。
另外命名函数还有两种写法：
函数表达式
var func = function() {
& console.log('a')
function func() {
& console.log('b')
其实这两个一起用的话可能会有问题，如
var func = function() {
& console.log('a')
function func() {
& console.log('b')
//输出为： a
因此目前多使用函数表达式的形式，但函数声明的性能如何呢？
var count =
& , sum&& = 0
function cb() {
while (count--) cb()
执行一下，并比较二者
$ time node named.js
real&&& 0m0.553s
user&&& 0m0.000s
sys&&&& 0m0.015s
$ time node named2.js
real&&& 0m0.529s
user&&& 0m0.000s
sys&&&& 0m0.047s
似乎函数声明会稍微快一点点，不过快得也非常非常不明显，个人还是建议函数声明式写法。
PS： 此数据均在Windows7下使用git-base测试。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
写go的时候，函数是像下面的哪种方式好，哪种性能更优？方式一：
package main
func main(){
var getCurrentTime = func() string{
return time.Now().Format(" 15:04:05")
fmt.Println(getCurrentTime())
package main
func main(){
fmt.Println(getCurrentTime())
func getCurrentTime() string {
return time.Now().Format(" 15:04:05")
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
非匿名函数(命名函数)性能好些匿名函数每次都需要重新解释(解释这个词可能不准确)回调，但是命名函数只需要解释一次，因此性能会有提升，但是性能差异其实很小，使用的时候视情况而定。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
按照题主给的例子肯定是方式二更好，但使不使用匿名函数是看具体的使用场景。更多的时候匿名函数是和闭包一起使用
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
Rob Pike's 5 Rules of ProgrammingRule 1: You can't tell where a program is going to spend its time. Bottlenecks occur in surprising places, so don't try to second guess and put in a speed hack until you've proven that's where the bottleneck is.
自己做一下benchmark
func NamedFunc() string {
return getCurrentTime()
func AnonymousFunc() string {
var f = func() string {
return time.Now().Format(" 15:04:05")
return f()
func getCurrentTime() string {
return time.Now().Format(" 15:04:05")
var str = ""
func BenchmarkNamedFunc(b *testing.B) {
for i := 0; i & b.N; i++ {
str = NamedFunc()
func BenchmarkAnonymousdFunc(b *testing.B) {
for i := 0; i & b.N; i++ {
str = AnonymousFunc()
我做的结果:
goos: linux
goarch: amd64
BenchmarkNamedFunc-8
BenchmarkAnonymousdFunc-8
_/home/singlethread/test/src/definedfunc
同步到新浪微博
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。正文 .NET开发中性能的基本要领及优化建议
.NET开发中性能的基本要领及优化建议
发布时间： & 编辑：www.jquerycn.cn
jquery中文网为您提供.NET开发中性能的基本要领及优化建议等资源，欢迎您收藏本站，我们将为您提供最新的.NET开发中性能的基本要领及优化建议资源
老赵的.NET程序性能的基本要领说起Roslyn大家肯定都已经有所耳闻了，这是下一代C#和VB.NET的编译器实现。Roslyn使用纯托管代码开发，但性能超过之前使用C
编写的原生实现。Bill Chiles是Roslyn的PM（程序经理，Program Manager），他最近写了一篇文章叫做《Essential Performance Facts and .NET Framework Tips》，其中总结了几条经验，目前是个CodePlex上的PDF文件，以后可能会发布在MSDN上。他在文章里谈到以下几点：&&& 不要进行过早优化。程序员有了一定经验以后，往往会对性能有所直觉，但也要避免盲目优化。&&& 没有评测，便是猜测。例如，有的时候重复计算都比使用哈希表进行缓存来的快。&&& 好工具很重要。这里他推荐了PerfView，这是个微软发布的免费工具，将来分析某些案例时我可能也会用到这个工具。&&& 性能的关键，在于内存分配。凭直觉可能很多人会觉得编译器是一个CPU密集型的场景，但实际上它终究还是个IO密集型的程序。&&& 其他一些细节。例如，对于字典的内存开销要有一些概念，还有例如我每次面试都会问到的class与struct的区别等等。第4点值得多说几句。对于托管环境来说，GC对于性能的影响重大。假如一段程序写的不够GC友好，让GC发生的多，尤其是那种Stop-the-World GC，这对性能的影响远胜某些“多花了几条拷贝指令”之类的“探索”。而且很多时候，用户眼中的“性能”在于程序的“响应程度（responsiveness）”，一旦GC暂停了所有的线程，程序便很容易发生卡顿，这甚至不是通过简单评测程序性能能够体现出来的。相较于Java平台来说，.NET已经是个相对GC友好的运行环境了。其中最重要的方面之一便是自定义值类型，即struct。struct让程序员进行一定程度上可控的内存分配，避免在堆上产生对象。而在Java中，只有几种原生类型是值类型，它们还不能包含成员。要知道在Java里无法使用一个未装箱的int值作为一个字典的键，这对一个.NET程序员来说可能很难想象，但事实便是如此。当然，Java似乎已经有打算作这方面的改进，但离真正可用还遥遥无期。目前Java只能通过一些如逃逸分析的手段，发现某个对象不会被共享到堆上，于是便将其分配在栈上，避免对GC产生压力。不过.NET提供再多对GC友好的功能，也抵不过开发人员的误用。Bill的文章里举了一些常见案例，这些其实都是每个.NET开发人员必须了解的基础。最后那个例子颇为有趣，他谈到，对于性能敏感的地方，有时候都要避免LINQ或Lambda。因为使用Lambda构造匿名函数时，编译器会产生闭包，因为所谓闭包，便是一个用来保存上下文的，分配在堆上的对象。此外，如List&T&的迭代器被有意实现为struct，但使用通用的LINQ接口，则会被转化为IEnumerable&T&和IEnumerator&T&，进而产生装箱。无独有偶，不久前@连城404在新浪微博上说到：&&& 按照Michael的建议把HiveTableScan关键路径上的FP风格的代码换成while循环加可复用的mutable对象，扫表性能提升40%。”，这其实也正和这次的话题密切相关。&&& 半夜不清醒，四则运算都算错了…发上条微博的时候实际上是提升了100%多点。之后继续蚊子腿上刮肉，不光是while循环，关键路径上的模式匹配代码也能刮出油水（例如省掉Array.unapplySeq调用开销）。目前使用LazySimpleSerDe的普通CVS表扫表性能提到2.2x，RCFile加上列剪枝可以提到3x。#Spark SQL#而Alan Perlis同样说过：&&& Lisp programmers know the value of everything but the cost of nothing.可谓颇为有趣。常用的FP手段的确会带来性能开销，这是事实，不过假如你现在立即得出“不要用FP”或“还好没学FP”这样的结论，那我也只能用怜悯的眼光看着你了。.NET程序的性能要领和优化建议本文提供了一些性能优化的建议，这些经验来自于使用托管代码重写C# 和 VB编译器，并以编写C# 编译器中的一些真实场景作为例子来展示这些优化经验。.NET 平台开发应用程序具有极高的生产力。.NET 平台上强大安全的编程语言以及丰富的类库，使得开发应用变得卓有成效。但是能力越大责任越大。我们应该使用.NET框架的强大能力，但同时如果我们需要处理大量的数据比如文件或者数据库也需要准备对我们的代码进行调优。为什么来自新的编译器的性能优化经验也适用于您的应用程序微软使用托管代码重写了C#和Visual Basic的编译器，并提供了一些列新的API来进行代码建模和分析、开发编译工具，使得Visual Studio具有更加丰富的代码感知的编程体验。重写编译器，并且在新的编译器上开发Visual Studio的经验使得我们获得了非常有用的性能优化经验，这些经验也能用于大型的.NET应用，或者一些需要处理大量数据的APP上。你不需要了解编译器，也能够从C#编译器的例子中得出这些见解。Visual Studio使用了编译器的API来实现了强大的智能感知(Intellisense)功能，如代码关键字着色，语法填充列表，错误波浪线提示，参数提示，代码问题及修改建议等，这些功能深受开发者欢迎。Visual Studio在开发者输入或者修改代码的时候，会动态的编译代码来获得对代码的分析和提示。当用户和App进行交互的时候，通常希望软件具有好的响应性。输入或者执行命令的时候，应用程序界面不应该被阻塞。帮助或者提示能够迅速显示出来或者当用户继续输入的时候停止提示。现在的App应该避免在执行长时间计算的时候阻塞UI线程从而让用户感觉程序不够流畅。想了解更多关于新的编译器的信息，可以访问 .NET Compiler Platform (&Roslyn&) http://roslyn.codeplex.com/基本要领在对.NET 进行性能调优以及开发具有良好响应性的应用程序的时候，请考虑以下这些基本要领：要领一:不要过早优化编写代码比想象中的要复杂的多，代码需要维护，调试及优化性能。 一个有经验的程序员，通常会对自然而然的提出解决问题的方法并编写高效的代码。 但是有时候也可能会陷入过早优化代码的问题中。比如，有时候使用一个简单的数组就够了，非要优化成使用哈希表，有时候简单的重新计算一下可以，非要使用复杂的可能导致内存泄漏的缓存。发现问题时，应该首先测试性能问题然后再分析代码。要领二:没有评测，便是猜测剖析和测量不会撒谎。测评可以显示CPU是否满负荷运转或者是存在磁盘I/O阻塞。测评会告诉你应用程序分配了什么样的以及多大的内存，以及是否CPU花费了很多时间在垃圾回收上。应该为关键的用户体验或者场景设置性能目标，并且编写测试来测量性能。通过使用科学的方法来分析性能不达标的原因的步骤如下：使用测评报告来指导，假设可能出现的情况，并且编写实验代码或者修改代码来验证我们的假设或者修正。如果我们设置了基本的性能指标并且经常测试，就能够避免一些改变导致性能的回退(regression)，这样就能够避免我们浪费时间在一些不必要的改动中。要领三:好工具很重要好的工具能够让我们能够快速的定位到影响性能的最大因素(CPU，内存，磁盘)并且能够帮助我们定位产生这些瓶颈的代码。微软已经发布了很多性能测试工具比如：Visual Studio Profiler, Windows Phone Analysis Tool, 以及 PerfView.PerfView是一款免费且性能强大的工具，他主要关注影响性能的一些深层次的问题(磁盘 I/O，GC 事件，内存)，后面会展示这方面的例子。我们能够抓取性能相关的 Event Tracing for Windows(ETW)事件并能以应用程序，进程，堆栈，线程的尺度查看这些信息。PerfView能够展示应用程序分配了多少，以及分配了何种内存以及应用程序中的函数以及调用堆栈对内存分配的贡献。这些方面的细节，您可以查看随工具下载发布的关于PerfView的非常详细的帮助，Demo以及视频教程（比如Channel9 上的视频教程）要领四：所有的都与内存分配相关你可能会想，编写响应及时的基于.NET的应用程序关键在于采用好的算法，比如使用快速排序替代冒泡排序，但是实际情况并不是这样。编写一个响应良好的app的最大因素在于内存分配，特别是当app非常大或者处理大量数据的时候。在使用新的编译器API开发响应良好的IDE的实践中，大部分工作都花在了如何避免开辟内存以及管理缓存策略。PerfView追踪显示新的C# 和VB编译器的性能基本上和CPU的性能瓶颈没有关系。编译器在读入成百上千甚至上万行代码，读入元数据活着产生编译好的代码，这些操作其实都是I/O bound 密集型。UI线程的延迟几乎全部都是由于垃圾回收导致的。.NET框架对垃圾回收的性能已经进行过高度优化，他能够在应用程序代码执行的时候并行的执行垃圾回收的大部分操作。但是，单个内存分配操作有可能会触发一次昂贵的垃圾回收操作，这样GC会暂时挂起所有线程来进行垃圾回收(比如 Generation 2型的垃圾回收)常见的内存分配以及例子这部分的例子虽然背后关于内存分配的地方很少。但是，如果一个大的应用程序执行足够多的这些小的会导致内存分配的表达式，那么这些表达式会导致几百M，甚至几G的内存分配。比如，在性能测试团队把问题定位到输入场景之前，一分钟的测试模拟开发者在编译器里面编写代码会分配几G的内存。装箱装箱发生在当通常分配在线程栈上或者数据结构中的值类型，或者临时的值需要被包装到对象中的时候（比如分配一个对象来存放数据，活着返回一个指针给一个Object对象）。.NET框架由于方法的签名或者类型的分配位置，有些时候会自动对值类型进行装箱。将值类型包装为引用类型会产生内存分配。.NET框架及语言会尽量避免不必要的装箱，但是有时候在我们没有注意到的时候会产生装箱操作。过多的装箱操作会在应用程序中分配成M上G的内存，这就意味着垃圾回收的更加频繁，也会花更长时间。在PerfView中查看装箱操作，只需要开启一个追踪（trace），然后查看应用程序名字下面的GC Heap Alloc 项（记住，PerfView会报告所有的进程的资源分配情况），如果在分配相中看到了一些诸如System.Int32和System.Char的值类型，那么就发生了装箱。选择一个类型，就会显示调用栈以及发生装箱的操作的函数。例1 string方法和其值类型参数下面的示例代码演示了潜在的不必要的装箱以及在大的系统中的频繁的装箱操作。public class Logger{&&& public static void WriteLine(string s)&&& {&&&&&&& /*...*/&&& }}public class BoxingExample{&&& public void Log(int id, int size)&&& {&&&&&&& var s = string.Format(&{0}:{1}&, id, size);&&&&&&& Logger.WriteLine(s);&&& }}这是一个日志基础类，因此app会很频繁的调用Log函数来记日志，可能该方法会被调用millons次。问题在于，调用string.Format方法会调用其重载的接受一个string类型和两个Object类型的方法：String.Format Method (String, Object, Object)该重载方法要求.NET Framework 把int型装箱为object类型然后将它传到方法调用中去。为了解决这一问题，方法就是调用id.ToString()和size.ToString()方法，然后传入到string.Format 方法中去，调用ToString()方法的确会导致一个string的分配，但是在string.Format方法内部不论怎样都会产生string类型的分配。你可能会认为这个基本的调用string.Format 仅仅是字符串的拼接，所以你可能会写出这样的代码：var s = id.ToString()
':'
size.ToString();实际上，上面这行代码也会导致装箱，因为上面的语句在编译的时候会调用：string.Concat(Object, Object, Object);这个方法，.NET Framework 必须对字符常量进行装箱来调用Concat方法。解决方法：完全修复这个问题很简单，将上面的单引号替换为双引号即将字符常量换为字符串常量就可以避免装箱，因为string类型的已经是引用类型了。var s = id.ToString()
size.ToString();例2 枚举类型的装箱下面的这个例子是导致新的C# 和VB编译器由于频繁的使用枚举类型，特别是在Dictionary中做查找操作时分配了大量内存的原因。public enum Color { Red, Green, Blue }public class BoxingExample{&&&&&& private C&&& public override int GetHashCode()&&& {&&&&&&& return name.GetHashCode() ^ color.GetHashCode();&&& }}问题非常隐蔽，PerfView会告诉你enmu.GetHashCode()由于内部实现的原因产生了装箱操作，该方法会在底层枚举类型的表现形式上进行装箱，如果仔细看PerfView，会看到每次调用GetHashCode会产生两次装箱操作。编译器插入一次，.NET Framework插入另外一次。解决方法：通过在调用GetHashCode的时候将枚举的底层表现形式进行强制类型转换就可以避免这一装箱操作。((int)color).GetHashCode()另一个使用枚举类型经常产生装箱的操作时enum.HasFlag。传给HasFlag的参数必须进行装箱，在大多数情况下，反复调用HasFlag通过位运算测试非常简单和不需要分配内存。要牢记基本要领第一条，不要过早优化。并且不要过早的开始重写所有代码。 需要注意到这些装箱的耗费，只有在通过工具找到并且定位到最主要问题所在再开始修改代码。字符串字符串操作是引起内存分配的最大元凶之一，通常在PerfView中占到前五导致内存分配的原因。应用程序使用字符串来进行序列化，表示JSON和REST。在不支持枚举类型的情况下，字符串可以用来与其他系统进行交互。当我们定位到是由于string操作导致对性能产生严重影响的时候，需要留意string类的Format(),Concat(),Split(),Join(),Substring()等这些方法。使用StringBuilder能够避免在拼接多个字符串时创建多个新字符串的开销，但是StringBuilder的创建也需要进行良好的控制以避免可能会产生的性能瓶颈。例3 字符串操作在C#编译器中有如下方法来输出方法前面的xml格式的注释。public void WriteFormattedDocComment(string text){&&& string[] lines = text.Split(new[] {&\r\n&, &\r&, &\n&},&&&&&&& StringSplitOptions.None);&&& int numLines = lines.L&&& bool skipSpace =&&& if (lines[0].TrimStart().StartsWith(&///&))&&& {&&&&&&& for (int i = 0; i & numL i
)&&&&&&& {&&&&&&&&&&& string trimmed = lines[i].TrimStart();&&&&&&&&&&& if (trimmed.Length & 4 || !char.IsWhiteSpace(trimmed[3]))&&&&&&&&&&& {&&&&&&&&&&&&&&& skipSpace =&&&&&&&&&&&&&&&&&&&&&&&&&& }&&&&&&& }&&&&&&& int substringStart = skipSpace ? 4 : 3;&&&&&&& for (int i = 0; i & numL i
)&&&&&&&&&&& Console.WriteLine(lines[i].TrimStart().Substring(substringStart));&&& }&&& else&&& {&&&&&&& /* ... */&&& }}可以看到，在这片代码中包含有很多字符串操作。代码中使用类库方法来将行分割为字符串，来去除空格，来检查参数text是否是XML文档格式的注释，然后从行中取出字符串处理。在WriteFormattedDocComment方法每次被调用时，第一行代码调用Split()就会分配三个元素的字符串数组。编译器也需要产生代码来分配这个数组。因为编译器并不知道，如果Splite()存储了这一数组，那么其他部分的代码有可能会改变这个数组，这样就会影响到后面对WriteFormattedDocComment方法的调用。每次调用Splite()方法也会为参数text分配一个string，然后在分配其他内存来执行splite操作。WriteFormattedDocComment方法中调用了三次TrimStart()方法，在内存环中调用了两次，这些都是重复的工作和内存分配。更糟糕的是，TrimStart()的无参重载方法的签名如下：namespace System{ &&& public class String &&& { &&&&&&& public string TrimStart(params char[] trimChars);&&& }}该方法签名意味着，每次对TrimStart()的调用都回分配一个空的数组以及返回一个string类型的结果。最后，调用了一次Substring()方法，这个方法通常会导致在内存中分配新的字符串。解决方法：和前面的只需要小小的修改即可解决内存分配的问题不同。在这个例子中，我们需要从头看，查看问题然后采用不同的方法解决。比如，可以意识到WriteFormattedDocComment()方法的参数是一个字符串，它包含了方法中需要的所有信息，因此，代码只需要做更多的index操作，而不是分配那么多小的string片段。下面的方法并没有完全解，但是可以看到如何使用类似的技巧来解决本例中存在的问题。C#编译器使用如下的方式来消除所有的额外内存分配。private int IndexOfFirstNonWhiteSpaceChar(string text, int start){&&& while (start & text.Length && char.IsWhiteSpace(text[start])) &&&&&&&&&&}private bool TrimmedStringStartsWith(string text, int start, string prefix){&&& start = IndexOfFirstNonWhiteSpaceChar(text, start); &&& int len = text.Length - &&& if (len & prefix.Length)&&& for (int i = 0; i & i
)&&& {&&&&&&& if (prefix[i] != text[start
i]) &&&&&&&&&&&&&& }&&&}WriteFormattedDocComment() 方法的第一个版本分配了一个数组，几个子字符串，一个trim后的子字符串，以及一个空的params数组。也检查了”///”。修改后的代码仅使用了index操作，没有任何额外的内存分配。它查找第一个非空格的字符串，然后逐个字符串比较来查看是否以”///”开头。和使用TrimStart()不同，修改后的代码使用IndexOfFirstNonWhiteSpaceChar方法来返回第一个非空格的开始位置，通过使用这种方法，可以移除WriteFormattedDocComment()方法中的所有额外内存分配。例4 StringBuilder本例中使用StringBuilder。下面的函数用来产生泛型类型的全名：public class Example { &&& // Constructs a name like &SomeType&T1, T2, T3&& &&& public string GenerateFullTypeName(string name, int arity) &&& { &&&&&&& StringBuilder sb = new StringBuilder();&&&&&&& sb.Append(name);&&&&&&& if (arity != 0)&&&&&&& { &&&&&&&&&&& sb.Append(&&&);&&&&&&&&&&& for (int i = 1; i & i
)&&&&&&&&&&& {&&&&&&&&&&&&&&& sb.Append(&T&); sb.Append(i.ToString()); sb.Append(&, &);&&&&&&&&&&& } &&&&&&&&&&& sb.Append(&T&); sb.Append(i.ToString()); sb.Append(&&&);&&&&&&& }&&&&&&& return sb.ToString(); &&& }}注意力集中到StringBuilder实例的创建上来。代码中调用sb.ToString()会导致一次内存分配。在StringBuilder中的内部实现也会导致内部内存分配，但是我们如果想要获取到string类型的结果化，这些分配无法避免。解决方法：要解决StringBuilder对象的分配就使用缓存。即使缓存一个可能被随时丢弃的单个实例对象也能够显著的提高程序性能。下面是该函数的新的实现。除了下面两行代码，其他代码均相同// Constructs a name like &Foo&T1, T2, T3&& public string GenerateFullTypeName(string name, int arity){&&& StringBuilder sb = AcquireBuilder(); /* Use sb as before */ &&& return GetStringAndReleaseBuilder(sb);}关键部分在于新的 AcquireBuilder()和GetStringAndReleaseBuilder()方法：[ThreadStatic]private static StringBuilder cachedStringBprivate static StringBuilder AcquireBuilder(){&&& StringBuilder result = cachedStringB&&& if (result == null)&&& {&&&&&&& return new StringBuilder();&&& } &&& result.Clear(); &&& cachedStringBuilder = &&&}private static string GetStringAndReleaseBuilder(StringBuilder sb){&&& string result = sb.ToString(); &&& cachedStringBuilder = &&&}上面方法实现中使用了thread-static字段来缓存StringBuilder对象，这是由于新的编译器使用了多线程的原因。很可能会忘掉这个ThreadStatic声明。Thread-static字符为每个执行这部分的代码的线程保留一个唯一的实例。如果已经有了一个实例，那么AcquireBuilder()方法直接返回该缓存的实例，在清空后，将该字段或者缓存设置为null。否则AcquireBuilder()创建一个新的实例并返回，然后将字段和cache设置为null 。当我们对StringBuilder处理完成之后，调用GetStringAndReleaseBuilder()方法即可获取string结果。然后将StringBuilder保存到字段中或者缓存起来，然后返回结果。这段代码很可能重复执行，从而创建多个StringBuilder对象，虽然很少会发生。代码中仅保存最后被释放的那个StringBuilder对象来留作后用。新的编译器中，这种简单的的缓存策略极大地减少了不必要的内存分配。.NET Framework 和MSBuild 中的部分模块也使用了类似的技术来提升性能。简单的缓存策略必须遵循良好的缓存设计，因为他有大小的限制cap。使用缓存可能比之前有更多的代码，也需要更多的维护工作。我们只有在发现这是个问题之后才应该采缓存策略。PerfView已经显示出StringBuilder对内存的分配贡献相当大。LINQ和Lambdas表达式使用LINQ 和Lambdas表达式是C#语言强大生产力的一个很好体现，但是如果代码需要执行很多次的时候，可能需要对LINQ或者Lambdas表达式进行重写。例5 Lambdas表达式，List&T&，以及IEnumerable&T&下面的例子使用LINQ以及函数式风格的代码来通过编译器模型给定的名称来查找符号。class Symbol { &&& public string Name { } /*...*/}class Compiler { &&& private List&Symbol& &&& public Symbol FindMatchingSymbol(string name) &&& { &&&&&&& return symbols.FirstOrDefault(s =& s.Name == name); &&& }}新的编译器和IDE 体验基于调用FindMatchingSymbol，这个调用非常频繁，在此过程中，这么简单的一行代码隐藏了基础内存分配开销。为了展示这其中的分配，我们首先将该单行函数拆分为两行：Func&Symbol, bool& predicate = s =& s.Name == return symbols.FirstOrDefault(predicate);第一行中，lambda表达式 “s=&s.Name==name” 是对本地变量name的一个闭包。这就意味着需要分配额外的对象来为委托对象predict分配空间，需要一个分配一个静态类来保存环境从而保存name的值。编译器会产生如下代码：// Compiler-generated class to hold environment state for lambda private class Lambda1Environment { &&& public string capturedN &&& public bool Evaluate(Symbol s) &&& { &&&&&&& return s.Name == this.capturedN&&& } }// Expanded Func&Symbol, bool& predicate = s =& s.Name == Lambda1Environment l = new Lambda1Environment() { &&& capturedName = name}; var predicate = new Func&Symbol, bool&(l.Evaluate);两个new操作符（第一个创建一个环境类，第二个用来创建委托）很明显的表明了内存分配的情况。现在来看看FirstOrDefault方法的调用，他是IEnumerable&T&类的扩展方法，这也会产生一次内存分配。因为FirstOrDefault使用IEnumerable&T&作为第一个参数，可以将上面的展开为下面的代码：// Expanded return symbols.FirstOrDefault(predicate) ... IEnumerable&Symbol& enumerable =IEnumerator&Symbol& enumerator = enumerable.GetEnumerator(); while (enumerator.MoveNext()){ &&& if (predicate(enumerator.Current)) &&&&&&& return enumerator.C } return default(Symbol);symbols变量是类型为List&T&的变量。List&T&集合类型实现了IEnumerable&T&即可并且清晰地定义了一个迭代器，List&T&的迭代器使用了一种结构体来实现。使用结构而不是类意味着通常可以避免任何在托管堆上的分配，从而可以影响垃圾回收的效率。枚举典型的用处在于方便语言层面上使用foreach循环，他使用enumerator结构体在调用推栈上返回。递增调用堆栈指针来为对象分配空间，不会影响GC对托管对象的操作。在上面的展开FirstOrDefault调用的例子中，代码会调用IEnumerabole&T&接口中的GetEnumerator()方法。将symbols赋值给IEnumerable&Symbol&类型的enumerable 变量，会使得对象丢失了其实际的List&T&类型信息。这就意味着当代码通过enumerable.GetEnumerator()方法获取迭代器时，.NET Framework 必须对返回的值（即迭代器，使用结构体实现）类型进行装箱从而将其赋给IEnumerable&Symbol&类型的(引用类型) enumerator变量。解决方法：解决办法是重写FindMatchingSymbol方法，将单个语句使用六行代码替代，这些代码依旧连贯，易于阅读和理解，也很容易实现。public Symbol FindMatchingSymbol(string name) { &&& foreach (Symbol s in symbols)&&& { &&&&&&& if (s.Name == name) &&&&&&&&&&& &&& } &&& }代码中并没有使用LINQ扩展方法，lambdas表达式和迭代器，并且没有额外的内存分配开销。这是因为编译器看到symbol 是List&T&类型的集合，因为能够直接将返回的结构性的枚举器绑定到类型正确的本地变量上，从而避免了对struct类型的装箱操作。原先的代码展示了C#语言丰富的表现形式以及.NET Framework 强大的生产力。该着后的代码则更加高效简单，并没有添加复杂的代码而增加可维护性。Aync异步接下来的例子展示了当我们试图缓存一部方法返回值时的一个普遍问题：例6 缓存异步方法Visual Studio IDE 的特性在很大程度上建立在新的C#和VB编译器获取语法树的基础上，当编译器使用async的时候仍能够保持Visual Stuido能够响应。下面是获取语法树的第一个版本的代码：class Parser {&&& /*...*/ &&& public SyntaxTree Syntax&&& { &&&&&&& &&& } && &&&& public Task ParseSourceCode() &&& {&&&&&&& /*...*/ &&& } }class Compilation { &&& /*...*/ &&& public async Task&SyntaxTree& GetSyntaxTreeAsync() &&& { &&&&&&& var parser = new Parser(); // allocation &&&&&&& await parser.ParseSourceCode(); // expensive &&&&&&& return parser.S&&& } }可以看到调用GetSyntaxTreeAsync() 方法会实例化一个Parser对象，解析代码，然后返回一个Task&SyntaxTree&对象。最耗性能的地方在为Parser实例分配内存并解析代码。方法中返回一个Task对象，因此调用者可以await解析工作，然后释放UI线程使得可以响应用户的输入。由于Visual Studio的一些特性可能需要多次获取相同的语法树， 所以通常可能会缓存解析结果来节省时间和内存分配，但是下面的代码可能会导致内存分配：class Compilation { /*...*/&&& private SyntaxTree cachedR&&& public async Task&SyntaxTree& GetSyntaxTreeAsync() &&& { &&&&&&& if (this.cachedResult == null) &&&&&&& { &&&&&&&&&&& var parser = new Parser(); // allocation &&&&&&&&&&& await parser.ParseSourceCode(); // expensive &&&&&&&&&&& this.cachedResult = parser.S &&&&&&& } &&&&&&& return this.cachedR&&& }}代码中有一个SynataxTree类型的名为cachedResult的字段。当该字段为空的时候，GetSyntaxTreeAsync()执行，然后将结果保存在cache中。GetSyntaxTreeAsync()方法返回SyntaxTree对象。问题在于，当有一个类型为Task&SyntaxTree& 类型的async异步方法时，想要返回SyntaxTree的值，编译器会生出代码来分配一个Task来保存执行结果（通过使用Task&SyntaxTree&.FromResult()）。Task会标记为完成，然后结果立马返回。分配Task对象来存储执行的结果这个动作调用非常频繁，因此修复该分配问题能够极大提高应用程序响应性。解决方法：要移除保存完成了执行任务的分配，可以缓存Task对象来保存完成的结果。class Compilation { /*...*/&&& private Task&SyntaxTree& cachedR&&& public Task&SyntaxTree& GetSyntaxTreeAsync() &&& { &&&&&&& return this.cachedResult ?? (this.cachedResult = GetSyntaxTreeUncachedAsync()); &&& }&&& private async Task&SyntaxTree& GetSyntaxTreeUncachedAsync() &&& {&&&&&&& var parser = new Parser(); // allocation &&&&&&& await parser.ParseSourceCode(); // expensive &&&&&&& return parser.S &&& } }代码将cachedResult 类型改为了Task&SyntaxTree& 并且引入了async帮助函数来保存原始代码中的GetSyntaxTreeAsync()函数。GetSyntaxTreeAsync函数现在使用 null操作符，来表示当cachedResult不为空时直接返回，为空时GetSyntaxTreeAsync调用GetSyntaxTreeUncachedAsync()然后缓存结果。注意GetSyntaxTreeAsync并没有await调用GetSyntaxTreeUncachedAsync。没有使用await意味着当GetSyntaxTreeUncachedAsync返回Task类型时，GetSyntaxTreeAsync 也立即返回Task， 现在缓存的是Task，因此在返回缓存结果的时候没有额外的内存分配。其他一些影响性能的杂项在大的app或者处理大量数据的app中，还有几点可能会引发潜在的性能问题。字典在很多应用程序中，Dictionary用的很广，虽然字非常方便和高校，但是经常会使用不当。在Visual Studio以及新的编译器中，使用性能分析工具发现，许多dictionay只包含有一个元素或者干脆是空的。一个空的Dictionay结构内部会有10个字段在x86机器上的托管堆上会占据48个字节。当需要在做映射或者关联数据结构需要事先常量时间查找的时候，字典非常有用。但是当只有几个元素，使用字典就会浪费大量内存空间。相反，我们可以使用List&KeyValuePair&K,V&&结构来实现便利，对于少量元素来说，同样高校。如果仅仅使用字典来加载数据，然后读取数据，那么使用一个具有N（log(N)）的查找效率的有序数组，在速度上也会很快，当然这些都取决于的元素的个数。类和结构不甚严格的讲，在优化应用程序方面，类和结构提供了一种经典的空间/时间的权衡(trade off)。在x86机器上，每个类即使没有任何字段，也会分配12 byte的空间 (译注：来保存类型对象指针和同步索引块)，但是将类作为方法之间参数传递的时候却十分高效廉价，因为只需要传递指向类型实例的指针即可。结构体如果不撞向的话，不会再托管堆上产生任何内存分配，但是当将一个比较大的结构体作为方法参数或者返回值得时候，需要CPU时间来自动复制和拷贝结构体，然后将结构体的属性缓存到本地便两种以避免过多的数据拷贝。缓存性能优化的一个常用技巧是缓存结果。但是如果缓存没有大小上限或者良好的资源释放机制就会导致内存泄漏。在处理大数据量的时候，如果在缓存中缓存了过多数据就会占用大量内存，这样导致的垃圾回收开销就会超过在缓存中查找结果所带来的好处。结论在大的系统，或者或者需要处理大量数据的系统中，我们需要关注产生性能瓶颈症状，这些问题再规模上会影响app的响应性，如装箱操作、字符串操作、LINQ和Lambda表达式、缓存async方法、缓存缺少大小限制以及良好的资源释放策略、使用Dictionay不当、以及到处传递结构体等。在优化我们的应用程序的时候，需要时刻注意之前提到过的四点：&&& 不要进行过早优化——在定位和发现问题之后再进行调优。&&& 专业测试不会说谎——没有评测，便是猜测。&&& 好工具很重要。——下载PerfView，然后去看使用教程。&&& 内存分配决定app的响应性。——这也是新的编译器性能团队花的时间最多的地方。参考资料&&& 如果想观看关于这一话题的演讲，可以在Channel 9 上观看。&&& VS Profiler基础 http://msdn.microsoft.com/en-us/library/ms182372.aspx&&& .NET 英语程序性能分析工具一览 http://msdn.microsoft.com/en-us/library/hh156536.aspx&&& Windows Phone性能分析工具http://msdn.microsoft.com/en-us/magazine/hh781024.aspx&&& 一些C# 和VB性能优化建议 http://msdn.microsoft.com/en-us/library/ms173196(v=vs.110).aspx (注:原文中该链接无内容，连接地址应该使http://msdn.microsoft.com/en-us/library/ms173196(v=vs.100).aspx )&&& 一些高级优化建议 http://curah.microsoft.com/4604/improving-your-net-apps-startup-performance--------------------------------------------------------------------------以上就是这篇文章的全部内容，很多东西其实都很基础，比如值类型(如结构体)和引用类型(如类)的区别和使用场景，字符串的操作，装箱拆箱操作等，这些在CLR Via C# 这本书中有系统的描述和讲解。这里面特别需要强调的是很多时候我们并没有意识到发生了装箱操作，比如文中提到的枚举类型获取HashCode会导致装箱，和这个相同的一个问题是，通常在我们将值类型作为Dictionay的key的时候，Dictionay在内部实现会调用key的GetHashCode方法获取哈希值进行散列，默认方法就会导致装箱操作，之前面试的时候我也被问到过这个问题，在很早之前老赵写过一篇 防止装箱落实到底，只做一半也是失败 就专门讨论过这一问题，所以在写代码的时候需要格外注意。微软使用托管语言重写了C# 和Visual Basic编译器，并取得了比之前的编译器更好的效果，更重要的是该编译器已经开源，VS的很多强大的功能正是建立在该编译器的某些编译和分析结果之上。这正是编译器即服务的体现，即“传统的编译器像是一个黑盒，你在一端输入代码，而另一端便会生成.NET程序集或是对象代码等等。而这个黑盒却很神秘，你目前很难参与或理解它的工作。”现在编译器开源了，我们可以直接利用其中间生成的一些分析结果来为实现一些功能，比如C# Interactive (有时也称为REPL，即Read-Eval-Print-Loop)。厉害的话，可以重写一个简单的Visual Studio了。文章的作者从使用托管语言编写C# 和 Visual Baisc编译器中的性能优化实践讲解了性能优化的一些思考和建议，在很多方面，比如StringBuilder分配开销，async函数返回值的缓存，LINQ和Lambda表达式产生的额外内存分配方面令人印象深刻。还有一个很重要的方面就是不要盲目的没有根据的优化，首先定位和查找到造成产生性能问题的原因点最重要，以前我也经常使用CLR Profile, VS Profile以及dotTrace查看和分析应用程序的性能，文中提到了的PerfView工具是微软内部.NET Runtime团队使用的，能够看到一般工具不能提供的信息，功能很强大，在Channel9 上有该工具如何使用的详细介绍。后面会简单介绍下该工具如何使用。希望本文对您在优化.NET 应用程序的性能方面有所帮助。您可能感兴趣的文章：