Difference between lock(locker) and lock(variable_which_I_am_using)

Question

I'm using C# & .NEt 3.5. What is the difference between the OptionA and OptionB ?

class MyClass {     private object m_Locker = new object();     private Dicionary<string, object> m_Hash = new Dictionary<string, object>();      public void OptionA()     {         lock(m_Locker){            // Do something with the dictionary         }     }      public void OptionB()     {         lock(m_Hash){            // Do something with the dictionary         }     }        } 

I'm starting to dabble in threading (primarly for creating a cache for a multi-threaded app, NOT using the HttpCache class, since it's not attached to a web site), and I see the OptionA syntax in a lot of the examples I see online, but I don't understand what, if any, reason that is done over OptionB.

Answer 1

Option B uses the object to be protected to create a critical section. In some cases, this more clearly communicates the intent. If used consistently, it guarantees only one critical section for the protected object will be active at a time:

lock (m_Hash) {     // Across all threads, I can be in one and only one of these two blocks     // Do something with the dictionary } lock (m_Hash) {     // Across all threads, I can be in one and only one of these two blocks     // Do something with the dictionary } 

Option A is less restrictive. It uses a secondary object to create a critical section for the object to be protected. If multiple secondary objects are used, it's possible to have more than one critical section for the protected object active at a time.

private object m_LockerA = new object(); private object m_LockerB = new object();  lock (m_LockerA) {     // It's possible this block is active in one thread     // while the block below is active in another     // Do something with the dictionary } lock (m_LockerB) {     // It's possible this block is active in one thread     // while the block above is active in another     // Do something with the dictionary } 

Option A is equivalent to Option B if you use only one secondary object. As far as reading code, Option B's intent is clearer. If you're protecting more than one object, Option B isn't really an option.