return 语句应该在锁的内部还是外部？

Question

我刚刚意识到，在我的代码中的某个地方，我将 return 语句放在锁内，有时在锁外。哪个最好？

1)

void example()
{
    lock (mutex)
    {
    //...
    }
    return myData;
}

2)

void example()
{
    lock (mutex)
    {
    //...
    return myData;
    }

}

我应该使用哪一个？

Answer 1

本质上，使代码更简单。单点退出是一个不错的理想，但我不会为了实现它而将代码变形......如果替代方案是声明一个局部变量（在锁外），初始化它（在锁内）和然后将其返回（在锁外），那么我会说锁内的简单“返回 foo”要简单得多。

为了显示 IL 中的差异，让我们编写代码：

static class Program
{
    static void Main() { }

    static readonly object sync = new object();

    static int GetValue() { return 5; }

    static int ReturnInside()
    {
        lock (sync)
        {
            return GetValue();
        }
    }

    static int ReturnOutside()
    {
        int val;
        lock (sync)
        {
            val = GetValue();
        }
        return val;
    }
}

（请注意，我很乐意认为 ReturnInside 是 C# 的更简单/更简洁的位）

并查看 IL（发布模式等）：

.method private hidebysig static int32 ReturnInside() cil managed
{
    .maxstack 2
    .locals init (
        [0] int32 CS$1$0000,
        [1] object CS$2$0001)
    L_0000: ldsfld object Program::sync
    L_0005: dup 
    L_0006: stloc.1 
    L_0007: call void [mscorlib]System.Threading.Monitor::Enter(object)
    L_000c: call int32 Program::GetValue()
    L_0011: stloc.0 
    L_0012: leave.s L_001b
    L_0014: ldloc.1 
    L_0015: call void [mscorlib]System.Threading.Monitor::Exit(object)
    L_001a: endfinally 
    L_001b: ldloc.0 
    L_001c: ret 
    .try L_000c to L_0014 finally handler L_0014 to L_001b
} 

method private hidebysig static int32 ReturnOutside() cil managed
{
    .maxstack 2
    .locals init (
        [0] int32 val,
        [1] object CS$2$0000)
    L_0000: ldsfld object Program::sync
    L_0005: dup 
    L_0006: stloc.1 
    L_0007: call void [mscorlib]System.Threading.Monitor::Enter(object)
    L_000c: call int32 Program::GetValue()
    L_0011: stloc.0 
    L_0012: leave.s L_001b
    L_0014: ldloc.1 
    L_0015: call void [mscorlib]System.Threading.Monitor::Exit(object)
    L_001a: endfinally 
    L_001b: ldloc.0 
    L_001c: ret 
    .try L_000c to L_0014 finally handler L_0014 to L_001b
}

所以在 IL 级别上，它们 [给或取一些名字] 是相同的（我学到了一些东西 ;-p）。 因此，唯一合理的比较是本地编码风格的（高度主观的）法则......为了简单起见，我更喜欢ReturnInside，但我也不会对此感到兴奋。

Answer 2

这没有任何区别；它们都被编译器翻译成同一个东西。

为了澄清，任何一个都被有效地翻译成具有以下语义的东西：

T myData;
Monitor.Enter(mutex)
try
{
    myData= // something
}
finally
{
    Monitor.Exit(mutex);
}

return myData;

Answer 3

我肯定会把退货放在锁里。否则，您可能会冒另一个线程进入锁并在 return 语句之前修改您的变量的风险，从而使原始调用者收到与预期不同的值。

Answer 4

如果认为外面的锁看起来更好，但如果你最终将代码更改为：

return f(...)

如果 f() 需要在持有锁的情况下被调用，那么它显然需要在锁内，因此将返回值保持在锁内以保持一致性是有意义的。

Answer 5

视情况而定，

我将在这里违背常规。我通常会回到锁内。

通常变量 mydata 是一个局部变量。我喜欢在初始化局部变量时声明它们。我很少有数据在我的锁之外初始化我的返回值。

所以你的比较实际上是有缺陷的。虽然理想情况下这两个选项之间的差异会像您所写的那样，这似乎是对案例 1 的认可，但实际上它有点难看。

void example() { 
    int myData;
    lock (foo) { 
        myData = ...;
    }
    return myData
}

对比

void example() { 
    lock (foo) {
        return ...;
    }
}

我发现案例 2 更容易阅读，更难搞砸，尤其是对于短的 sn-ps。

Answer 6

对于它的价值，documentation on MSDN 有一个从锁内部返回的示例。从这里的其他答案来看，它似乎与 IL 非常相似，但对我来说，从锁内部返回似乎更安全，因为这样你就不会冒返回变量被另一个线程覆盖的风险。

Answer 7

为了让其他开发人员更容易阅读代码，我建议第一个替代方案。

Answer 8

lock() return <expression> 语句总是：

1) 进入锁

2) 为指定类型的值进行本地（线程安全）存储，

3) 用<expression>返回的值填充存储，

4) 退出锁

5) 退货。

这意味着从 lock 语句返回的值在返回之前总是“煮熟”。

别担心lock() return，这里不要听任何人的））

Answer 9

^{注意：我相信这个答案实际上是正确的，我希望它也有帮助，但我总是很乐意根据具体的反馈改进它。}

总结和补充现有答案：

• accepted answer 表明，无论您在 C# 代码中选择哪种语法形式，在 IL 代码中 - 因此在运行时 - return 直到 在锁被释放之后。

  • 即使将return 放在 lock 块内，严格来说，也歪曲了控制流^[1]，它在语法上是方便，因为它消除了将返回值存储在 aux 中的需要。局部变量（在块外声明，以便可以与块外的return 一起使用） - 请参阅Edward KMETT's answer。

• 单独 - 这方面是问题的附带，但可能仍然令人感兴趣（Ricardo Villamil's answer 试图解决它，但我认为不正确） - 将 lock 语句与return 语句 - 即，在防止并发访问的块中获取 return 的值 - 仅有意义地“保护”调用者范围内的返回值如果它没有'获得后实际上需要保护，适用于以下场景：

  • 如果返回值是集合中的一个元素，它只需要在添加和删除元素方面进行保护，而不是在元素本身的修改方面和/或...

  • ...如果返回的值是值类型或字符串的实例。

    • 请注意，在这种情况下，调用方会收到值的 快照（副本）^[2] - 到调用方检查时，它可能不再是原始数据结构中的当前值。

  • 在任何其他情况下，锁定必须由调用者执行，而不是（仅）在方法内部。

---

^{[1] Theodor Zoulias 指出从技术上讲，将 return 放置在 try、catch、using、if、while、for 中也是如此， ...声明；然而，lock 声明的特定目的可能会引起对真正控制流的审查，这一点已被提出并受到了很多关注。}

^{[2] 访问一个值类型实例总是会创建一个线程本地的、堆栈上的副本；尽管字符串在技术上是引用类型实例，但它们实际上表现得像值类型实例。}