使整个方法线程安全的最简单方法？

Question

似乎有很多关于多线程编程的知识，它有点吓人。

对于我目前的需要，我只是想防止的方法从另一个线程再次被称为完成之前，我的问题是：

这是适当的（安全）的方法，使方法线程安全？

class Foo 
{ 
    bool doingWork; 
    void DoWork() 
    { 
     if (doingWork) // <- sophistocated thread-safety 
      return;  // <- 

     doingWork = true; 

     try 
     { 
      [do work here] 
     } 
     finally 
     { 
      doingWork = false; 
     } 
    } 
} 

如果这还不够，什么是实现这一目标的最简单的方法？

---

编辑：关于方案更多信息：

• 有富的只有一个实例

• Foo.DoWork（）将被从线程池线程呼吁Elapsed System.Timers.Timer的事件。

• 通常Foo.DoWork（）将在下一次的 称为前完成劫，但我要为渺茫的机会，它会长期来看， 并获得完成之前再次调用代码。

---

（我还没有聪明到可以肯定，如果这个问题能够标记语言无关，所以我没有。开明的读者，可随时做，如果适用）。

Answer 1

您的代码不是线程安全的。您应该使用lock关键字。

在你当前的代码：

if (doingWork) 
     return; 

    // A thread having entered the function was suspended here by the scheduler. 

    doingWork = true; 

当一个线程来通过，它也将进入该功能。

这就是为什么应该使用lock结构。它基本上与您的代码，但没有一个线程的风险在中间被打断：

class Foo 
{ 
    object lockObject = new object; 
    void DoWork() 
    { 
     lock(lockObject) 
     { 
      [do work here] 
     } 
    } 
} 

注意，该代码比原来的略有不同的语义。这段代码将导致第二个线程进入等待状态，然后完成工作。您的原始代码使第二个线程中止。为了更接近您的原始代码，不能使用C＃lock语句。底层Monitor结构具有直接使用：

class Foo 
{ 
    object lockObject = new object; 
    void DoWork() 
    { 
     if(Monitor.TryEnter(lockObject)) 
     { 
      try 
      { 
       [do work here] 
      } 
      finally 
      { 
       Monitor.Exit(lockObject); 
      } 
     } 
    } 
} 

Answer 2

http://msdn.microsoft.com/en-us/library/system.threading.barrier.aspx

可能想使用屏障来代替它，它会为您完成所有工作。这是控制重入代码的标准方式。还允许您一次控制执行该工作的线程数量（如果允许超过1个）。

Answer 3

重新进入与多线程无关。

重入方法是一种方法，最终可以在同一个线程中从本身内部调用。
例如，如果方法引发事件，并且处理该事件的客户端代码在事件处理程序内再次调用该方法，则该方法是可重入的。
保护该方法免于再次入侵意味着确保如果从内部调用该方法，它将不会发出异常或抛出异常。

只要所有内容都在同一个线程中，您的代码就不会在同一个对象实例中重新进入。

除非[do work here]能够运行外部代码（例如，通过引发一个事件，或者通过调用其他代理或方法），它并不是重新进入的。

您编辑的问题表明整个部分与您无关。
无论如何你应该可以阅读它。

---

你可能是（编辑：是）寻找排他性 –确保如果同时调用多个线程的方法将不会运行两次一次。
您的代码不是唯一的。如果两个线程一次运行该方法，并且它们都一次运行if语句，则它们都会通过if，然后都设置doingWork标志，并且都将运行整个方法。

为此，请使用lock关键字。

Answer 4

如果你想容易代码和不约的表现太在意它可以那么容易，因为

class Foo 
{ 
    bool doingWork; 
object m_lock=new object(); 
    void DoWork() 
    { 
     lock(m_lock) // <- not sophistocated multithread protection 
{ 
     if (doingWork) 
      return;  
     doingWork = true; 
} 


     try 
     { 
      [do work here] 
     } 
     finally 
     { 
lock(m_lock) //<- not sophistocated multithread protection 
{ 
      doingWork = false; 
} 
     } 
    } 

}

如果你想封闭一点锁定，你可以创建一个像这样线程安全的属性：

public bool DoingWork 
{ 
get{ lock(m_Lock){ return doingWork;}} 
set{lock(m_lock){doingWork=value;}} 
} 

现在你可以用它来代替字段，但是它会导致更多的时间用于锁定原因使用次数增加。

或者你可以使用全栅栏的方法（从大螺纹书Joseph Albahari online threading）

class Foo 
{ 
    int _answer; 
    bool _complete; 

    void A() 
    { 
    _answer = 123; 
    Thread.MemoryBarrier(); // Barrier 1 
    _complete = true; 
    Thread.MemoryBarrier(); // Barrier 2 
    } 

    void B() 
    { 
    Thread.MemoryBarrier(); // Barrier 3 
    if (_complete) 
    { 
     Thread.MemoryBarrier();  // Barrier 4 
     Console.WriteLine (_answer); 
    } 
    } 
} 

他指出，全围栏2X比lock语句快。在某些情况下，您可以通过删除对MemoryBarrier（）的不必要的调用来提高性能，但使用lock很简单，更清晰且不易出错。

我相信这也可以使用基于INT的Interlocked类做基于int的工作领域。