74

我们已经看到很多关于何时以及为什么使用try/catch和try/ catch/的问题finally。而且我知道try/肯定有一个用例finally（特别是因为它是using语句的实现方式）。

我们还看到了有关try/catch 和 exceptions 开销的问题。

然而，我链接到的问题并没有谈到只尝试最终的开销。

假设块中发生的任何事情都没有异常，try确保finally语句在离开try块时执行（有时通过从函数返回）的开销是多少？

同样，我只问try/ finally，不catch，不抛出异常。

谢谢！

编辑：好的，我将尝试更好地展示我的用例。

我应该使用哪个，DoWithTryFinally或者DoWithoutTryFinally？

public bool DoWithTryFinally()
{
  this.IsBusy = true;

  try
  {
    if (DoLongCheckThatWillNotThrowException())
    {
      this.DebugLogSuccess();
      return true;
    }
    else
    {
      this.ErrorLogFailure();
      return false;
    }
  }
  finally
  {
    this.IsBusy = false;
  }
}

public bool DoWithoutTryFinally()
{
  this.IsBusy = true;

  if (DoLongCheckThatWillNotThrowException())
  {
    this.DebugLogSuccess();

    this.IsBusy = false;
    return true;
  }
  else
  {
    this.ErrorLogFailure();

    this.IsBusy = false;
    return false;
  }
}

这种情况过于简单，因为只有两个返回点，但想象一下，如果有四个……或十个……或一百个。

在某些时候，我想使用try/finally出于以下原因：

  • 遵守 DRY 原则（尤其是当退出点的数量越来越多时）
  • 如果事实证明我的内部函数没有抛出异常是错误的，那么我想确保this.Working设置为false.

因此，假设考虑到性能问题、可维护性和 DRY 原则，对于多少个退出点（特别是如果我可以假设所有内部异常都被捕获），我想招致与try/相关的任何性能损失finally？

编辑＃2：我将名称更改this.Working为this.IsBusy. 抱歉，忘了说这是多线程的（尽管实际上只有一个线程会调用该方法）；其他线程将轮询以查看对象是否正在工作。如果工作按预期进行，返回值只是成功或失败。

4

6 回答 6

101

为什么不看看你实际得到了什么？

这是 C# 中的一段简单代码：

    static void Main(string[] args)
    {
        int i = 0;
        try
        {
            i = 1;
            Console.WriteLine(i);
            return;
        }
        finally
        {
            Console.WriteLine("finally.");
        }
    }

这是调试版本中生成的 IL：

.method private hidebysig static void Main(string[] args) cil managed
{
    .entrypoint
    .maxstack 1
    .locals init ([0] int32 i)
    L_0000: nop 
    L_0001: ldc.i4.0 
    L_0002: stloc.0 
    L_0003: nop 
    L_0004: ldc.i4.1 
    L_0005: stloc.0 
    L_0006: ldloc.0 // here's the WriteLine of i 
    L_0007: call void [mscorlib]System.Console::WriteLine(int32)
    L_000c: nop 
    L_000d: leave.s L_001d // this is the flavor of branch that triggers finally
    L_000f: nop 
    L_0010: ldstr "finally."
    L_0015: call void [mscorlib]System.Console::WriteLine(string)
    L_001a: nop 
    L_001b: nop 
    L_001c: endfinally 
    L_001d: nop 
    L_001e: ret 
    .try L_0003 to L_000f finally handler L_000f to L_001d
}

这是在调试中运行时由 JIT 生成的程序集：

00000000  push        ebp 
00000001  mov         ebp,esp 
00000003  push        edi 
00000004  push        esi 
00000005  push        ebx 
00000006  sub         esp,34h 
00000009  mov         esi,ecx 
0000000b  lea         edi,[ebp-38h] 
0000000e  mov         ecx,0Bh 
00000013  xor         eax,eax 
00000015  rep stos    dword ptr es:[edi] 
00000017  mov         ecx,esi 
00000019  xor         eax,eax 
0000001b  mov         dword ptr [ebp-1Ch],eax 
0000001e  mov         dword ptr [ebp-3Ch],ecx 
00000021  cmp         dword ptr ds:[00288D34h],0 
00000028  je          0000002F 
0000002a  call        59439E21 
0000002f  xor         edx,edx 
00000031  mov         dword ptr [ebp-40h],edx 
00000034  nop 
        int i = 0;
00000035  xor         edx,edx 
00000037  mov         dword ptr [ebp-40h],edx 
        try
        {
0000003a  nop 
            i = 1;
0000003b  mov         dword ptr [ebp-40h],1 
            Console.WriteLine(i);
00000042  mov         ecx,dword ptr [ebp-40h] 
00000045  call        58DB2EA0 
0000004a  nop 
            return;
0000004b  nop 
0000004c  mov         dword ptr [ebp-20h],0 
00000053  mov         dword ptr [ebp-1Ch],0FCh 
0000005a  push        4E1584h 
0000005f  jmp         00000061 
        }
        finally
        {
00000061  nop 
            Console.WriteLine("finally.");
00000062  mov         ecx,dword ptr ds:[036E2088h] 
00000068  call        58DB2DB4 
0000006d  nop 
        }
0000006e  nop 
0000006f  pop         eax 
00000070  jmp         eax 
00000072  nop 
    }
00000073  nop 
00000074  lea         esp,[ebp-0Ch] 
00000077  pop         ebx 
00000078  pop         esi 
00000079  pop         edi 
0000007a  pop         ebp 
0000007b  ret 
0000007c  mov         dword ptr [ebp-1Ch],0 
00000083  jmp         00000072

现在，如果我注释掉 try 和 finally 和 return，我会从 JIT 中得到几乎相同的程序集。您将看到的区别是跳转到 finally 块和一些代码来确定在 finally 执行后去哪里。所以你在谈论微小的差异。在发行版中，跳转到 finally 将得到优化 - 大括号是 nop 指令，所以这将成为跳转到下一条指令，这也是一个 nop - 这是一个简单的窥视孔优化。pop eax 然后 jmp eax 同样便宜。

    {
00000000  push        ebp 
00000001  mov         ebp,esp 
00000003  push        edi 
00000004  push        esi 
00000005  push        ebx 
00000006  sub         esp,34h 
00000009  mov         esi,ecx 
0000000b  lea         edi,[ebp-38h] 
0000000e  mov         ecx,0Bh 
00000013  xor         eax,eax 
00000015  rep stos    dword ptr es:[edi] 
00000017  mov         ecx,esi 
00000019  xor         eax,eax 
0000001b  mov         dword ptr [ebp-1Ch],eax 
0000001e  mov         dword ptr [ebp-3Ch],ecx 
00000021  cmp         dword ptr ds:[00198D34h],0 
00000028  je          0000002F 
0000002a  call        59549E21 
0000002f  xor         edx,edx 
00000031  mov         dword ptr [ebp-40h],edx 
00000034  nop 
        int i = 0;
00000035  xor         edx,edx 
00000037  mov         dword ptr [ebp-40h],edx 
        //try
        //{
            i = 1;
0000003a  mov         dword ptr [ebp-40h],1 
            Console.WriteLine(i);
00000041  mov         ecx,dword ptr [ebp-40h] 
00000044  call        58EC2EA0 
00000049  nop 
        //    return;
        //}
        //finally
        //{
            Console.WriteLine("finally.");
0000004a  mov         ecx,dword ptr ds:[034C2088h] 
00000050  call        58EC2DB4 
00000055  nop 
        //}
    }
00000056  nop 
00000057  lea         esp,[ebp-0Ch] 
0000005a  pop         ebx 
0000005b  pop         esi 
0000005c  pop         edi 
0000005d  pop         ebp 
0000005e  ret

所以你说的是 try/finally 的成本非常非常低。很少有问题域对此很重要。如果您正在执行 memcpy 之类的操作并在要复制的每个字节周围尝试/最终尝试，然后继续复制数百 MB 的数据，我可以看到这是一个问题，但在大多数情况下？微不足道。

于 2010-11-05T15:23:31.200 回答
55

所以让我们假设有一个开销。那你要停止使用finally吗？希望不会。

仅当您可以在不同选项之间进行选择时，IMO 性能指标才有意义。我看不出如何在finally不使用的情况下获得语义finally。

于 2010-11-05T14:42:13.280 回答
28

try/finally非常轻巧。实际上，try/catch/finally只要不抛出异常也是如此。

我有一个快速的个人资料应用程序，我不久前做了一个测试它；在一个紧密的循环中，它实际上并没有增加执行时间。

我会再次发布它，但这真的很简单；只需运行一个紧密的循环来做某事，其中 atry/catch/finally不会在循环内引发任何异常，并将结果与​​没有try/catch/finally.

于 2010-11-05T14:42:48.537 回答
14

让我们实际为此添加一些基准数据。这个基准测试表明，实际上，尝试/最终的时间大约与调用空函数的开销一样小（可能更好的说法是：正如 IL 专家所说的那样：“跳转到下一条指令”多于）。

            static void RunTryFinallyTest()
            {
                int cnt = 10000000;

                Console.WriteLine(TryFinallyBenchmarker(cnt, false));
                Console.WriteLine(TryFinallyBenchmarker(cnt, false));
                Console.WriteLine(TryFinallyBenchmarker(cnt, false));
                Console.WriteLine(TryFinallyBenchmarker(cnt, false));
                Console.WriteLine(TryFinallyBenchmarker(cnt, false));

                Console.WriteLine(TryFinallyBenchmarker(cnt, true));
                Console.WriteLine(TryFinallyBenchmarker(cnt, true));
                Console.WriteLine(TryFinallyBenchmarker(cnt, true));
                Console.WriteLine(TryFinallyBenchmarker(cnt, true));
                Console.WriteLine(TryFinallyBenchmarker(cnt, true));

                Console.ReadKey();
            }

            static double TryFinallyBenchmarker(int count, bool useTryFinally)
            {
                int over1 = count + 1;
                int over2 = count + 2;

                if (!useTryFinally)
                {
                    var sw = Stopwatch.StartNew();
                    for (int i = 0; i < count; i++)
                    {
                        // do something so optimization doesn't ignore whole loop. 
                        if (i == over1) throw new Exception();
                        if (i == over2) throw new Exception();
                    }
                    return sw.Elapsed.TotalMilliseconds;
                }
                else
                {
                    var sw = Stopwatch.StartNew();
                    for (int i = 0; i < count; i++)
                    {
                        // do same things, just second in the finally, make sure finally is 
                        // actually doing something and not optimized out
                        try
                        {
                            if (i == over1) throw new Exception();
                        } finally
                        {
                            if (i == over2) throw new Exception();
                        }
                    }
                    return sw.Elapsed.TotalMilliseconds;
                }
            }

结果：33,33,32,35,32 63,64,69,66,66（毫秒，确保你有代码优化）

因此，在1000 万次循环中，try/finally 的开销约为 33 毫秒。

每次尝试/最后，我们正在谈论 0.033/10000000 =

try/finally 的 3.3 纳秒或 33 亿分之一秒的开销。

于 2012-04-05T23:08:38.990 回答
6

安德鲁巴伯所说的。除非抛出异常，否则实际的 TRY/CATCH 语句不会增加任何/可忽略的开销。最后真的没什么特别的。在 try+catch 语句中的代码完成后，您的代码总是跳转到 finally

于 2010-11-05T15:17:59.373 回答
6

在较低级别中，如果条件不满足，则与此finally一样昂贵。else它实际上是汇编程序（IL）中的一个跳转。

于 2010-11-05T15:23:38.017 回答