メソッド全体をスレッドセーフにする最も簡単な方法は？

Question

マルチスレッドプログラミングについて学ぶことはたくさんあるようですが、それはやや威圧的です。私の現在のニーズに

、私はちょうどそれが終了する前に再び別のスレッドから呼び出されるメソッドから保護したい、と私の質問は：

これは作るための適切な（安全な）方法ですメソッドはスレッドセーフですか？

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

     doingWork = true; 

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

それが十分でない場合は、これを実現する最も簡単な方法は何ですか？

---

EDIT：シナリオについての詳細情報：

• がfooのインスタンスが1つしかない

Foo.DoWorkは（）にThreadPoolのスレッドから呼び出されます

• 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] 
     } 
    } 
} 

注：これは、基本的にはあなたのコードと同じですが、途中で中断されたスレッドのリスクなしに行います。このコードでは、2番目のスレッドが待機してから作業を開始します。元のコードで2番目のスレッドがただちに中止されました。元のコードに近づくために、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

リエントラントはマルチスレッドとは関係ありません。

リエントラント方式とは、同じスレッド上で自身の内部から呼び出される方法です。
たとえば、メソッドがイベントを発生させ、そのイベントを処理するクライアントコードがイベントハンドラ内でメソッドを再度呼び出す場合、そのメソッドはリエントラントです。
このメソッドを再入可能から保護するということは、内部から呼び出すと、anyhtingも例外もスローされないことを保証することを意味します。

あなたのコードは、すべてが同じスレッド上にある限り、同じオブジェクトインスタンス内の再入場から保護されています。

[do work here]は、外部コードを実行することができない限り（例えば、イベントを発生させることによって、または他のものからデリゲートやメソッドを呼び出すことによって）、最初は再入可能ではありません。

編集した質問は、このセクション全体があなたとは無関係であることを示しています。
あなたはおそらくそれをとにかく読むべきです。同時に複数のスレッドによって呼び出された場合、このメソッドは二回、一度に実行されないことを保証する独占 –を探して：

---

あなたは（あるEDIT）であってもよいです。
コードは排他的ではありません。 2つのスレッドが一度にメソッドを実行し、両方とも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); 
    } 
    } 
} 

をフルフェンス・アプローチを使用することができ、彼は完全なフェンスがロックの文よりも速く2倍であることを述べています。場合によっては、MemoryBarrier（）への不要な呼び出しを削除することでパフォーマンスを向上させることができますが、lockを使用すると、シンプルで、はっきりとしたエラーが発生しにくくなります。

私はこれも、Interlockedクラスのint based doingWorkフィールドを使って行うことができると信じています。