When would you ever use nested locking?

I was reading in Albahari's excellent eBook on threading and came across the following scenario he mentions that "a thread can repeatedly lock the same object in a nested (reentrant) fashion"

lock (locker)
  lock (locker)
    lock (locker)
    {
       // Do something...
    }

as well as

static readonly object _locker = new object();

static void Main()
{
  lock (_locker)
  {
     AnotherMethod();
     // We still have the lock - because locks are reentrant.
  }
}

static void AnotherMethod()
{
  lock (_locker) { Console.WriteLine ("Another method"); }
}

From the explanation, any threads will block on the first (outermost) lock and that it is unlocked only after the outer lock has exited.

He states "nested locking is useful when one method calls another within a lock"

Why is this useful? When would you NEED to do this and what problem does it solve?