using System;
using System.Threading;

public class Program
{
    static void Main()
    {
        Program p = new Program();
        p.Run();
    }

    private ManualResetEvent _event = new ManualResetEvent(false);
    private AutoResetEvent _readyThread1 = new AutoResetEvent(false);
    private AutoResetEvent _readyThread2 = new AutoResetEvent(false);

    public void Run()
    {
        Thread t1 = new Thread(new ThreadStart(threadProc1));
        t1.Name = "Thread1";
        t1.IsBackground = true;
        Thread t2 = new Thread(new ThreadStart(threadProc2));
        t2.Name = "Thread1";
        t2.IsBackground = true;

        // переводим свой поток в очередь более главных потоков, чтобы время в первую очередь доставалось текущему потоку и в последнюю очередь, когда он добровольно отдаст управление, потокам t1 и t2...
        t1.Priority = ThreadPriority.BelowNormal;
        t2.Priority = ThreadPriority.BelowNormal;
        Thread.CurrentThread.Priority = ThreadPriority.Highest;    
        
        
        t1.Start();
        t2.Start();
        _readyThread1.WaitOne();
        _readyThread2.WaitOne();

        Console.WriteLine("Set/Reset...");
        _event.Set();
        _event.Reset();

        // разрешаем делиться временем с потоками t1 и t2...
        t1.Priority = ThreadPriority.Normal;
        t2.Priority = ThreadPriority.Normal;
        Thread.CurrentThread.Priority = ThreadPriority.Normal;


        // событие было установлено и сброшено, но потоки не проснутся (если процессу доступно не более 1 процессора!)
        Console.WriteLine("Wait for processing...");
        Thread.Sleep(5000);
        Console.WriteLine("Exit...");
    }

    private void threadProc1()
    {
        _readyThread1.Set();
        _event.WaitOne();
        Console.WriteLine("T1");
    }

    private void threadProc2()
    {
        _readyThread2.Set();
        _event.WaitOne();
        Console.WriteLine("T2");
    }
}

_M_>>специально для таких случаев предназначены методы Monitor.Pulse() и Monitor.PulseAll(), тебе в данном случае нужен Monitor.PulseAll()

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

private object function()
{
    lock(_syncFunction)
    {    
        if(_syncFunctionBusy)
            return null;
        _syncFunctionBusy = true;
    }
    try
    {
        //...
        //...
        return new object();
    }
    finally
    {
        lock(_syncFunction)
            _syncFunctionBusy = false;
    }
}

А>Как мне здеть может помочь Monitor и PulseAll, объясни плз поподробнее..

_M_>>тогда вам такой подход не нужен, вам нужен обычный lock, без всяких возвратов null

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()
{
    if( MethodSynchronized() == null )
    {
       methodDone.WaitOne();
    }
}

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.");
        }
    }
}

private static object _synch = new object();

private static void Test() {
    if(Monitor.TryEnter(_synch)) {
        Console.WriteLine("Start Calculating {0}!!!", Thread.CurrentThread.ManagedThreadId);
        Thread.Sleep(1000); // DO LONG_RUNNING-CALCULATIONS
        Console.WriteLine("Finished Calculating {0}!!!", Thread.CurrentThread.ManagedThreadId);

        Monitor.Exit(_synch);
    } else {
        Console.WriteLine("Start Waiting {0}!!!", Thread.CurrentThread.ManagedThreadId);
        lock(_synch) ;
        Console.WriteLine("Finish Waiting {0}!!!", Thread.CurrentThread.ManagedThreadId);
    }
}

class Program
    {
        static void Main(string[] args)
        {
            Thread t1 = new Thread(ThreadProc);
            Thread t2 = new Thread(ThreadProc);
            Thread t3 = new Thread(ThreadProc);
            t1.Start();
            t2.Start();
            t3.Start();

            t1.Join();
            t2.Join();
            t3.Join();
        }

        public static object sync1 = new object();
        public static object sync2 = new object();
        public static void ThreadProc()
        {            
            if (Monitor.TryEnter(sync1))
            {
                try
                {
                    DoSmth();
                    lock (sync2)
                    {
                        Monitor.PulseAll(sync2);
                    }
                }
                finally
                {
                    Monitor.Exit(sync1);
                }

            }
            else
            {
                lock (sync2)
                {
                    Monitor.Wait(sync2);
                }
            }
        }

        public static void DoSmth()
        {
            Console.WriteLine("i'm here");
        }
    }

АМ>class Program
АМ>    {
АМ>        static void Main(string[] args)
АМ>        {
АМ>            Thread t1 = new Thread(ThreadProc);
АМ>            Thread t2 = new Thread(ThreadProc);
АМ>            Thread t3 = new Thread(ThreadProc);
АМ>            t1.Start();
АМ>            t2.Start();
АМ>            t3.Start();

АМ>            t1.Join();
АМ>            t2.Join();
АМ>            t3.Join();
АМ>        }

АМ>        public static object sync1 = new object();
АМ>        public static object sync2 = new object();
АМ>        public static void ThreadProc()
АМ>        {            
АМ>            if (Monitor.TryEnter(sync1))
АМ>            {
АМ>                try
АМ>                {
АМ>                    DoSmth();
АМ>                    lock (sync2)
АМ>                    {
АМ>                        Monitor.PulseAll(sync2);
АМ>                    }
АМ>                }
АМ>                finally
АМ>                {
АМ>                    Monitor.Exit(sync1);
АМ>                }

АМ>            }
АМ>            else
АМ>            {
//Эмулируем переключение контекста в этот момент.
                   Thread.Sleep(100);
АМ>                lock (sync2)
АМ>                {
АМ>                    Monitor.Wait(sync2);
АМ>                }
АМ>            }
АМ>        }

АМ>        public static void DoSmth()
АМ>        {
АМ>            Console.WriteLine("i'm here");
АМ>        }
АМ>    }

 class Program
    {
        static void Main(string[] args)
        {
            Thread t1 = new Thread(ThreadProc);
            Thread t2 = new Thread(ThreadProc);
            Thread t3 = new Thread(ThreadProc);
            t1.Start();
            t2.Start();
            t3.Start();

            t1.Join();
            t2.Join();
            t3.Join();
        }

        public static object sync1 = new object();
        public static object sync2 = new object();
        public static object sync3 = new object();
        public static bool flag = false;
        public static void ThreadProc()
        {
            bool res = false;
            lock (sync3)
            {
                res = Monitor.TryEnter(sync1);
                if(res)
                    lock (sync2) 
                        flag = false;
            }

            if (res)
            {
                try
                {
                    DoSmth();                    
                }
                finally
                {
                    lock (sync2)
                    {
                        flag = true;
                        Monitor.PulseAll(sync2);
                    }
                    Monitor.Exit(sync1);
                }

            }
            else
            {
                Thread.Sleep(100);
                lock (sync2)
                {
                    if(!flag)
                        Monitor.Wait(sync2);
                }
            }
        }

        public static void DoSmth()
        {
            Thread.Sleep(100);
            Console.WriteLine("i'm here");
        }
    }

if (Monitor.TryEnter(sync))
try
{
  return DoSomething();
}
finally
{
  Monitor.Exit(sync)
}
return null;