老赵再简单讲解一下尾递归的优化原理，希望能给大家以一定理性认识。
尾递归的循环优化
尾递归，即是递归调用放在方法末尾的递归方式，如经典的阶乘：
int FactorialTailRecursion(int n, int acc) { if (n == 0) return acc; return FactorialTailRecursion(n - 1, acc * n); }
由于递归在方法的末尾，因此方法中的局部变量已经毫无用处，编译器完全可以将其“复用”，并把尾递归优化为“循环”方式：
int FactorialLoopOptimized(int n, int acc) { while (true) { if (n == 0) return acc; acc *= n; n--; } }
不过，上文还提到了尾递归中的常用技巧Continuation。那么对于如下形式的Continuation，编译器又该如何优化呢？
int FactorialContinuation(int n, Func<int, int> continuation) { if (n == 0) return continuation(1); return FactorialContinuation(n - 1, r => continuation(n * r)); }
我们先用“人脑”来思考一下，这段代码的执行方式是怎么样的。我们每次使用n和contn调用FactorialContinuation时，都会构造一个新的contn - 1，并同n - 1传入下一次FactorialContinuation调用中去。以此类推，直到n等于0时，就直接调用cont0并返回。至于每个Continuation的定义，我们可以归纳出如下结果：
Func<int, int> contn = r => r * n
因此：
Factorial(n)
= contn(contn - 1(...(cont2(cont1(cont0(1)))...))
= n * ((n – 1) * (...(2 * (1 * 1))...)) =
= n * (n - 1) * ... * 2 * 1
= n!
于是，我们可以根据这个“意图”，将FactorialContinuation方法“优化”为如下形式：
int FactorialLoopOptimized2(int n, Func<int, int> continuation) { LinkedList<Func<int, int>> contList = new LinkedList
<Func<int, int>>(); while (true) { if (n == 0) break; int tempN = n; Func<int, int> newCont = r => tempN * r; contList.AddFirst(newCont); n--; continuation = newCont; } return contList.Aggregate(1, (acc, cont) => cont(acc)); }
我们构造了一个Continuation函数链表，随着n递减，每次都会把新的Continuation函数插入到链表头，最后Aggregate方法会将第一个参数（累加器）依次运用到每个函数中去，得到最后结果并返回。只可惜，这个优化完全是我们“一厢情愿”而已，这么做的前提是“理解”了函数的意义，把方法的迭代调用“拆开”，而编译器是无法（还是很难）帮我们优化到如斯地步的。那么编译器对于此类问题又该如何解决呢？
之前，我们使用C#中的匿名方法特性来构造每个Continuation方法。如果我们使用自定义的封装类，再将递归“优化”成循环，FactorialContinuation又会成为什么样呢？如下：
private class Continuation { public Continuation(Func<int, int> cont, int n) { this.cont = cont; this.n = n; } private Func<int, int> cont; private int n; public int Invoke(int r) { return this.cont(this.n * r); } } public static int FactorialLoopOptimized3(int n,
Func<int, int> continuation) { while (true) { if (n == 0) break; continuation = new Continuation(continuation, n).Invoke; n--; } return continuation(1); }
其实这才是FactorialContinuation的“直译”，也是编译器能够进行优化。不过朋友们应该也能够看出，这只是一个Continuation对象套着另一个Continuation对象。如果形成了数万个Continuation对象的嵌套，在最终调用最外层的Continuation时，每个内部的Continuation也会在调用时往同一个堆栈中不断累加，最终还是会造成堆栈溢出。因此，如果使用了Continuation，还是无法简单把递归优化成循环来避免堆栈溢出的。编译器还必须进行其他方面的优化。
方法尾调用的优化
上一篇文章曾经谈到：“与普通递归相比，由于尾递归的调用处于方法的最后，因此方法之前所积累下的各种状态对于递归调用结果已经没有任何意义，因此完全可以把本次方法中留在堆栈中的数据完全清除，把空间让给最后的递归调用。这样的优化便使得递归不会在调用堆栈上产生堆积，意味着即时是“无限”递归也不会让堆栈溢出”。这其实才是尾递归的“正统”优化方式，那么我们先暂时忘记之前的“循环优化”，从最简单的示例中查看这样的优化是如何进行的。还是最简单的“尾递归”阶乘：
static int FactorialTailRecursion(int n, int acc) { if (n == 0) return acc; return FactorialTailRecursion(n - 1, acc * n); }
它的IL代码是：
.method private hidebysig static int32
FactorialTailRecursion(int32 n, int32 acc) cil managed { .maxstack 8 L_0000: ldarg.0 // 加载第1个参数，即n L_0001: brtrue.s L_0005 // 如果第一个参数不为0，则跳转到L_0005 L_0003: ldarg.1
// 运行到此，说明第1个参数为0，则加载第2个参数，即acc L_0004: ret // 返回（刚加载的第2个参数） L_0005: ldarg.0 // 加载第1个参数，即n L_0006: ldc.i4.1 // 加载数值1 L_0007: sub // 将两者相减，即n - 1 L_0008: ldarg.1 // 加载第2个参数，即acc L_0009: ldarg.0 // 加载第1个参数，即n L_000a: mul // 将两者相乘，即acc * n // 把n - 1和acc * n作为参数递归调用 L_000b: call int32 TailRecursion.
Recursion::FactorialTailRecursion(int32, int32) L_0010: ret // 返回递归调用结果 }
在这个问题上，我们还需要观察它的汇编代码（为了不干扰文章内容，老赵会把获取汇编代码的做法单独写一篇文章，稍后发布），如下：
00ad00d0 push ebp 00ad00d1 mov ebp,esp 00ad00d3 push esi 00ad00d4 mov eax,edx 00ad00d6 test ecx,ecx 00ad00d8 jne 00ad00dd 00ad00da pop esi 00ad00db pop ebp 00ad00dc ret 00ad00dd lea edx,[ecx-1] 00ad00e0 imul ecx,eax 00ad00e3 mov esi,ecx 00ad00e5 test edx,edx 00ad00e7 jne 00ad00ed 00ad00e9 mov eax,esi 00ad00eb jmp 00ad00f9 00ad00ed lea ecx,[edx-1] 00ad00f0 imul edx,esi 00ad00f3 call dword ptr ds:[703068h]
(地址703068h的值即为00ad00d0) 00ad00f9 pop esi 00ad00fa pop ebp 00ad00fb ret
上面的汇编代码非常简单，从中可以看出，每次递归调用都使用了最简单的call指令，没有经过任何有效的优化或调整。因此在不断地递归调用之后，终究会出现堆栈溢出。这就是普通递归的缺陷。而对于尾递归来说，MSIL提供了额外的tail指令表示“尾调用”1，它只需简单补充在IL指令call, callvirt, calli之前便可。因此我们使用ildasm.exe将IL代码dump出来，并在call之前加上tail指令：
.method private hidebysig static int32
FactorialTailRecursion(int32 n, int32 acc) cil managed { .maxstack 8 L_0000: ldarg.0 L_0001: brtrue.s L_0005 L_0003: ldarg.1 L_0004: ret L_0005: ldarg.0 L_0006: ldc.i4.1 L_0007: sub L_0008: ldarg.1 L_0009: ldarg.0 L_000a: mul L_000b: tail. L_000c: call int32 TailRecursion.Recursion::
FactorialTailRecursion(int32, int32) L_0010: ret }
使用ilasm.exe重新编译之后运行，再重新察看FactorialTailRecursion的汇编代码：
00a600d0 push ebp 00a600d1 mov ebp,esp 00a600d3 push edi 00a600d4 push esi 00a600d5 push ebx 00a600d6 mov eax,ecx 00a600d8 mov esi,edx 00a600da test eax,eax 00a600dc jne 00a600e5 00a600de mov eax,esi 00a600e0 pop ebx 00a600e1 pop esi 00a600e2 pop edi 00a600e3 pop ebp 00a600e4 ret 00a600e5 lea ecx,[eax-1] 00a600e8 imul eax,esi 00a600eb mov edx,eax 00a600ed mov eax,dword ptr ds:[813068h] 00a600f3 push 0 00a600f5 push 0 00a600f7 push 1 00a600f9 push eax 00a600fa cmp dword ptr
[mscorwks!g_TrapReturningThreads (7204339c)],0 00a60101 je 00a6010c 00a60103 push ecx 00a60104 push edx 00a60105 call mscorwks!JIT_PollGC (71d5c9d3) 00a6010a pop edx 00a6010b pop ecx 00a6010c call mscorwks!JIT_TailCall (71b02890) 00a60111 int 3
在这里我实在无法完整讲述上述汇编代码的含义，不过从中可以看出它的确对于尾递归进行了特别的处理，而并非使用简单的call指令进行调用。对此互联网上的资源也不多，老赵只找到了Shri Borde的一篇文章，其中简单描述了Whidbey V2（真早）中CLR对于这方面的处理，以及一些相关的考虑，从中似乎能够看出一些苗头来。
让我们再回想之前的问题：Continuation无法通过简单优化为循环来解决递归问题。但是通过观察可以看出，Continuation.Invoke方法中的cont委托调用是最后一条命令，这说明它是一个“尾调用”——虽然不是“尾递归”，不过这已经满足tail指令的要求了：只需和所在方法返回值相同（或兼容）即可。因此，对于Continuation来说，我们也需要进行尾递归的优化。您可以进行尝试，现在无论递归多“深”，都不会使堆栈溢出了。
注1：与tail类似，IL指令jmp也能够用于方法调用。这两条指令都不会在调用栈上堆积数据。tail与jmp的不同之处在于，前者只需要返回值与所在方法相同或兼容即可，而后者需要签名完全相同。您可以想象得到，对于“直接递归”来说，可以使用jmp进行调用，而普通的“尾调用”，则只能使用tail了。
