C # using lock practice

Question

I have a critical section in my application that contains a lot of code: which is the best way to block access in threadMethod:

A) block the whole block:

private object locker = new object();

private void threadMethod()
{
   while(true)
   {
      lock(locker)
      {
         // do work - a lot of code here
      }
      Thread.Sleep(2000);
   }
}

B) Use an additional locked access element canWork:

 private static object locker = new object();
 private bool canWork;
 private bool CanWork
 { 
     get { lock(locker) { return this.canWork; } }
     set { lock(locker) { this.canWork = value; } } 
 }

  private void threadMethod()
  {
     while(true)
     {
        if(CanWork)
        {
           // do work - a lot of code here
        }
        Thread.Sleep(2000);
     }
  }

and somewhere in the code

CanWork = false;

Answer 1

Nothing special.

• The first drawback is that you hold the lock for a long time.
• The second drawback is that the state may change after verification.

(, ). , , , , .

Answer 2

, , . " " / ?

Answer 3

Instead, I would use a monitor. Plus, do you really want to (yet) because it will happen forever?

  private object syncObject = new object();

  private void threadMethod()
  {
   bool tryToRun = true;
   while(tryToRun)
   {
    if(Monitor.TryEnter(syncObject))
    {
     tryToRun = false;

     // do work - a lot of code here

     Monitor.Exit(syncObject);
    }
    else
    {
     Thread.Sleep(2000); // Possibly knock this up the how long you expect the lock to be held for.
    }
   }
  }

Answer 4

est link:

http://msdn.microsoft.com/en-us/magazine/cc188793.aspx#fig7

The best use is to declare a new private synchronization object - use "lock (synObject) {code here ...}