What's the use of the SyncRoot pattern?

Question

I'm reading a c# book that describes the SyncRoot pattern. It shows

void doThis() {     lock(this){ ... } }  void doThat() {     lock(this){ ... } } 

and compares to the SyncRoot pattern:

object syncRoot = new object();  void doThis() {     lock(syncRoot ){ ... } }  void doThat() {     lock(syncRoot){ ... } } 

However, I don't really understand the difference here; it seems that in both cases both methods can only be accessed by one thread at a time.

The book describes ... because the object of the instance can also be used for synchronized access from the outside and you can't control this form the class itself, you can use the SyncRoot pattern Eh? 'object of the instance'?

Can anyone tell me the difference between the two approaches above?

Answer 1

If you have an internal data structure that you want to prevent simultaneous access to by multiple threads, you should always make sure the object you're locking on is not public.

The reasoning behind this is that a public object can be locked by anyone, and thus you can create deadlocks because you're not in total control of the locking pattern.

This means that locking on this is not an option, since anyone can lock on that object. Likewise, you should not lock on something you expose to the outside world.

Which means that the best solution is to use an internal object, and thus the tip is to just use Object.

Locking data structures is something you really need to have full control over, otherwise you risk setting up a scenario for deadlocking, which can be very problematic to handle.