Произошла блокировка, и дальнейшие попытки блокировки не блокируются: повторяются ли блокировки C #?

Я написал тест того, что, по моему мнению, должно быть допустимым случаем для тупик. Похоже, что после того, как блокировка была получена экземпляром класса a, этому экземпляру больше не нужно повторно получать блокировку , даже если я явно попытаюсь вызвать другую метод, который должен снова заблокировать .

Вот класс:

internal class Tester
{
    private readonly object _sync = new object();

    public Tester() { }

    public void TestLock()
    {
        lock (_sync)
        {
            for (int i = 0; i < 10; i++)
            {
                Deadlock(i);
            }
        }

    }

    private void Deadlock(int i)
    {
        lock (_sync)
        {
            Trace.WriteLine(i + " no deadlock!");
        }
    }
}

Вывод:

0 тупика нет!
Я написал тест, который, по моему мнению, должен быть допустимым случаем тупика. Похоже, что после того, как блокировка была получена экземпляром класса a, этому экземпляру не нужно повторно получать ...

Я написал тест того, что, по моему мнению, должно быть допустимым случаем для тупик. Похоже, что после того, как блокировка была получена экземпляром класса a, этому экземпляру больше не нужно повторно получать блокировку , даже если я явно попытаюсь вызвать другую метод, который должен снова заблокировать .

Вот класс:

internal class Tester
{
    private readonly object _sync = new object();

    public Tester() { }

    public void TestLock()
    {
        lock (_sync)
        {
            for (int i = 0; i < 10; i++)
            {
                Deadlock(i);
            }
        }

    }

    private void Deadlock(int i)
    {
        lock (_sync)
        {
            Trace.WriteLine(i + " no deadlock!");
        }
    }
}

Вывод:

0 тупика нет!
Я написал тест, который, по моему мнению, должен быть допустимым случаем тупика. Похоже, что после того, как блокировка была получена экземпляром класса a, этому экземпляру не нужно повторно получать ...

Я написал тест того, что, по моему мнению, должно быть допустимым случаем для тупик. Похоже, что после того, как блокировка была получена экземпляром класса a, этому экземпляру больше не нужно повторно получать блокировку , даже если я явно попытаюсь вызвать другую метод, который должен снова заблокировать .

Вот класс:

internal class Tester
{
    private readonly object _sync = new object();

    public Tester() { }

    public void TestLock()
    {
        lock (_sync)
        {
            for (int i = 0; i < 10; i++)
            {
                Deadlock(i);
            }
        }

    }

    private void Deadlock(int i)
    {
        lock (_sync)
        {
            Trace.WriteLine(i + " no deadlock!");
        }
    }
}

Вывод:

0 тупика нет!
Я написал тест, который, по моему мнению, должен быть допустимым случаем тупика. Похоже, что после того, как блокировка была получена экземпляром класса a, этому экземпляру больше не нужно повторно получать блокировку , даже если я явно попытаюсь вызвать другую метод, который должен снова заблокировать .

Вот класс:

internal class Tester
{
    private readonly object _sync = new object();

    public Tester() { }

    public void TestLock()
    {
        lock (_sync)
        {
            for (int i = 0; i < 10; i++)
            {
                Deadlock(i);
            }
        }

    }

    private void Deadlock(int i)
    {
        lock (_sync)
        {
            Trace.WriteLine(i + " no deadlock!");
        }
    }
}

Вывод:

0 тупика нет!
Я написал тест, который, по моему мнению, должен быть допустимым случаем тупика. Похоже, что после того, как блокировка была получена экземпляром класса a, этому экземпляру больше не нужно повторно получать блокировку , даже если я явно попытаюсь вызвать другую метод, который должен снова заблокировать .

Вот класс:

internal class Tester
{
    private readonly object _sync = new object();

    public Tester() { }

    public void TestLock()
    {
        lock (_sync)
        {
            for (int i = 0; i < 10; i++)
            {
                Deadlock(i);
            }
        }

    }

    private void Deadlock(int i)
    {
        lock (_sync)
        {
            Trace.WriteLine(i + " no deadlock!");
        }
    }
}

Вывод:

0 тупика нет!
1 без тупика!
2 без тупика!
3 без тупика!
4 нет тупика!
5 нет тупика!
6 без тупика!
7 без тупика!
8 нет тупика!
9 нет тупика!

Я бы подумал, что это вызовет тупик ... может ли кто-нибудь пролить свет на это?