Гарантирует ли lock () получение в запрошенном порядке ?

Когда несколько потоков запрашивают блокировку одного и того же объекта, гарантирует ли CLR, что блокировки будут получены в том порядке, в котором они были запрошены?

] Я написал тест, чтобы убедиться, что это правда, и похоже, что это да, но я не уверен, что это окончательно.

class LockSequence
{
    private static readonly object _lock = new object();

    private static DateTime _dueTime;

    public static void Test()
    {
        var states = new List<State>();

        _dueTime = DateTime.Now.AddSeconds(5);

        for (int i = 0; i < 10; i++)
        {
            var state = new State {Index = i};
            ThreadPool.QueueUserWorkItem(Go, state);
            states.Add(state);
            Thread.Sleep(100);
        }

        states.ForEach(s => s.Sync.WaitOne());
        states.ForEach(s => s.Sync.Close());
    }

    private static void Go(object state)
    {
        var s = (State) state;

        Console.WriteLine("Go entered: " + s.Index);

        lock (_lock)
        {
            Console.WriteLine("{0,2} got lock", s.Index);
            if (_dueTime > DateTime.Now)
            {
                var time = _dueTime - DateTime.Now;
                Console.WriteLine("{0,2} sleeping for {1} ticks", s.Index, time.Ticks);
                Thread.Sleep(time);
            }
            Console.WriteLine("{0,2} exiting lock", s.Index);
        }

        s.Sync.Set();
    }

    private class State
    {
        public int Index;
        public readonly ManualResetEvent Sync = new ManualResetEvent(false);
    }
}

Распечатки:

Введено: 0

0 заблокировано

0 спит на 49979998 тиков

Введено: 1

Введено: 2

Введено: 3

Введено: 4

Введено: 5

Введено: 6

Введено: 7

Введено: 8

Введено: 0/24 ?