if(Monitor.TryEnter(synchObj))
{
    try
    {
        Call();
        Monitor.PulseAll();
    }
    finaly
    {
        Monitor.Exit(synchObj);
    }
}
else
{
    Monitor.Wait(synchObj);
}

private readonly object _syncFunction = new object();
private bool _syncFunctionBusy = false;

private ManualResetEvent methodDone = new ManualResetEvent(false);

private object MethodSynchronized()
{
    lock(_syncFunction)
    {    
        if(_syncFunctionBusy)
        {
            methodDone.Reset();

            return null;
        }
        _syncFunctionBusy = true;
    }
    try
    {
        //...
        //...
        return new object();
    }
    finally
    {
        lock(_syncFunction)
        {
            _syncFunctionBusy = false;
            
             methodDone.Set();
        }
    }
}

private void CallSynchronized()//это пример одного из методов, которые не должнны вызывать 
//MethodSynchronized() одновременно из нескольких потоков
{
    if( MethodSynchronized() == null )//уже выполняется?
    {
       methodDone.WaitOne();//просто ожидаем его завершения
    }
}

M>>Это чего, вместо простого lock(...) писать 60 строчек кода? Лихо.

А>Я был бы тебе признатален, если бы ты показал, как "правильно"

private readonly object _syncFunction = new object();

private object MethodSynchronized()
{
    lock(_syncFunction)    //уже выполняется? тогда просто ожидаем его завершения
    {    
        //...
        //...
        return new object();
    }
}

private void CallSynchronized()//это пример одного из методов, которые не должнны вызывать MethodSynchronized() одновременно из нескольких потоков
{
    MethodSynchronized()
}

E>if(Monitor.TryEnter(synchObj))
E>{
E>    try
E>    {
E>        Call();
E>        Monitor.PulseAll();
E>    }
E>    finaly
E>    {
E>        Monitor.Exit(synchObj);
E>    }
E>}
E>else
E>{
E>    Monitor.Wait(synchObj);
E>}
E>

The thread that currently owns the lock on the specified object invokes this method in order to release the object so that another thread can access it.

А>Я был бы тебе признатален, если бы ты показал, как "правильно"

readonly object sync = new object();

private void NeverCallMeWhileIAmRunning()
{
 // 80%+10%+5%+3%+2%+1%
}

public void CallTheBloodyMethod()
{
    lock( sync )
    {
        NeverCallMeWhileIAmRunning();
    }
}

class Program
{
    private static void Main()
    {
        for( int i = 0; i < 200; i++ )
        {
            new Thread(MethodSynchronized).Start();
        }
    }

    private static int invocationCount = 0;
    private static readonly ManualResetEvent jobDone = new ManualResetEvent(false);

    private static void MethodSynchronized()
    {
        if( Interlocked.CompareExchange(ref invocationCount, 1, 0) == 0 )
        {
            Console.WriteLine(Thread.CurrentThread.ManagedThreadId + " acquired the lock");
            try
            {
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId + " is doing some processing...");
                Thread.Sleep(100);
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId + " finished processing...");
            }
            finally
            {
                Console.WriteLine(Thread.CurrentThread.ManagedThreadId + " releasing waiting threads...");

                jobDone.Set();
                Interlocked.Exchange(ref invocationCount, 0);
            }
        }
        else
        {
            Console.WriteLine(Thread.CurrentThread.ManagedThreadId + " is waiting...");

            Thread.Sleep(0);

            jobDone.Reset();
            jobDone.WaitOne();

            Console.WriteLine(Thread.CurrentThread.ManagedThreadId + " finished waiting. returns.");
        }
    }
}