[RESOLVED] deadlock not occuring?

[dannystommen]

I have the following code

private static readonly object Lock = new object();

public static void Test(){ //call this Test1
  lock(Lock){
    Test(true);
  }
}

public static void Test(bool value){ //call this Test2
  lock(Lock){
    //do something
  }
}

Now, when I call the first Test() method without an parameter, shouldn't this result in a deadlock? Because Test1 is locks "Lock", then calls Test2, and now Test2 also wants to lock the same object. Am I missing something?

[vcdebugger]

try this...

public static void Test1(){ //call this Test1
  lock(Lock){
    Test2(true);
  }
}

public static void Test2(bool value){ //call this Test2
  lock(Lock){
    //do something
  }
}

[dannystommen]

Also works fine. (That was actually my original situation)

[Mutant_Fruit]

A lock statement guarantees that only *one* thread can take that lock, but that one thread can take the lock as many times as they want. This scenario will not deadlock.

[Arjay]

Along with what Mutant_Fruit has said. The same thread can acquire the lock multiple times, but different threads cannot. The whole point of thread synchronization is to prevent different threads from accessing the same resource. There is no problem when the same thread accesses the same resource multiple times.

If you want a deadlock, modify the code to rename the methods Test1 and Test2 and add a Sleep statement to Test2. In one thread call Test2, and then call Test1 in another thread.

 
private static readonly object Lock = new object();

public static void Test1(){ //call this from T1
  lock(Lock){
    Test2(true);
  }
}

public static void Test2(){ //call this from T2
  lock(Lock){
    Sleep( 10000 );
    //do something
  }
}

[dannystommen]

Thanks for your explanations. Now I understand it completly. But since the example is using only 1 object that is locked, a deadlock will not occur. It tried your example Arjay, but it executed just fine. Thread 1 and 2 are started at the same time, and 2 will wait with execution till 1 has finished.

To get a deadlock, at least 2 different objects needs to be locked.
Example that works

      private static readonly object LockA = new object();
      private static readonly object LockB = new object();

      public static void Test1() {
         lock (LockA) {
            Thread.Sleep(1000);
            lock (LockB) {
               Test2(true);
            }
         }
      }

      public static void Test2(object value) {
         lock (LockB) {
            Thread.Sleep(1000);
            lock (LockA) {
               //do something
            }
         }
      }

      static void Main(string[] args) {
         Thread t = new Thread(new ParameterizedThreadStart(Test2));
         t.Start(false);
         Thread t2 = new Thread(Test1);
         t2.Start();
      }

In this case, LockA is waiting for LockB and vice versa

[Arjay]

That's fine Danny. I generally write my code so it doesn't deadlock. Forgive me if I didn't get it right the first time.

[dannystommen]

I ussualy also write my code so that it doesn't deadlock. But my trainee wrote some code that I thought would result in a deadlock, but it didn't. That explains my post :-)