Здравствуйте, <Аноним>, Вы писали:

А>Мне нужно, что если метод MethodSynchronized() уже выполнятеся ОДИМ потоком, он не мог выполняться в других.
А>НО ПРИ ЭТОМ, "другие" методы, пытающиеся выхвать MethodSynchronized из других потоков, просто дождались выполнения MethodSynchronized()
А>И НЕ ЗАПУСКАЛИ его, т.е. просто сделали return.

Вот так не пойдет?

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

Здравствуйте, Lloyd, Вы писали:

L>Вот так не пойдет?
L>

L>private static object _synch = new object();

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

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

А вот это уже похоже на то что нужно. И кода совсем немного.
Надо прикинуть как это влезет в уже существующий код. Спасибо!

Здравствуйте, <Аноним>, Вы писали:

А>А вот это уже похоже на то что нужно. И кода совсем немного.
А>Надо прикинуть как это влезет в уже существующий код. Спасибо!

Да не за что.

P.S. Для спасибо есть кнопка.

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, Lloyd, Вы писали:

L>>Вот так не пойдет?
L>>

L>>private static object _synch = new object();

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

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

А>А вот это уже похоже на то что нужно. И кода совсем немного.
А>Надо прикинуть как это влезет в уже существующий код. Спасибо!

Что-то вечером вчера я не туда смотрел похоже
Это решение тоже не дает нужного поведения. Ведь когда мы входим в lock, после Monitor.Exit только один поток освободится, а мне надо чтобы освободились все, которые можгут ждать.

M>>

M>>readonly object sync = new object();

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

M>>public void CallTheBloodyMethod()
M>>{
M>>    if( Monitor.TryEnter( sync ) )
     try 
M>>    {
M>>        NeverCallMeWhileIAmRunning();
M>>    }
     finally { Monitor.Leave(sync); }
M>>}
M>>

Здравствуйте, mihailik, Вы писали:

M>>>

M>>>readonly object sync = new object();

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

M>>>public void CallTheBloodyMethod()
M>>>{
M>>>    if( Monitor.TryEnter( sync ) )
M>     try 
M>>>    {
M>>>        NeverCallMeWhileIAmRunning();
M>>>    }
M>     finally { Monitor.Leave(sync); }
M>>>}
M>>>

В этом варианте, если CallTheBloodyMethod будет вызван из потока в то время, когда он уже выполняется каким-либо другим потоком, этот метод просто завершится, а мне надо чтоб он дождался пока другой поток не закончит его выполнение.

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

Здравствуйте, Александр Малафеев, Вы писали:

[]

А вот это действительно похоже на правду

Здравствуйте, <Аноним>, Вы писали:

А>Что-то вечером вчера я не туда смотрел похоже
А>Это решение тоже не дает нужного поведения. Ведь когда мы входим в lock, после Monitor.Exit только один поток освободится, а мне надо чтобы освободились все, которые можгут ждать.

Тебе имеет смысл подменять каждый раз объект синхронизации:

т.е. поток выполняющий функцию, создаёт новый объект синхронизации и назначает его в качестве текущего объекта синхронизации. Остальные потоки ожидают освобождения текущего объекта синхронизации.
После того, как функция завершена, поток сбрасывает текущий объект синхронизации в null, а затем освобождает сам объект синхронизации.

Наличие назначенного текущего объекта синхронизации есть признак того, что функция уже выполняется.

Здравствуйте, Александр Малафеев, Вы писали:

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

По логике должно зависнуть.

Здравствуйте, GlebZ, Вы писали:

GZ>По логике должно зависнуть.

Не должно и не виснет..

Здравствуйте, GlebZ, Вы писали:

GZ>Здравствуйте, Александр Малафеев, Вы писали:

Согласен,
Но тогда можно как нибуть так

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

Без sync3 можно обойтись и вместо него просто заюзать sync2

Здравствуйте, Александр Малафеев, Вы писали:

АМ>Без sync3 можно обойтись и вместо него просто заюзать sync2

Да вроде и так не виснет

Здравствуйте, Александр Малафеев, Вы писали:

Мне вообще непонятен смысл данного кода. Он эквивалентен:

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

Здравствуйте, GlebZ, Вы писали:

GZ>Здравствуйте, Александр Малафеев, Вы писали:

GZ>Мне вообще непонятен смысл данного кода. Он эквивалентен:
GZ>

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

GZ>

Неа. Тот код ждет пока не завершится выполнение метода в другом потоке и потом выходит

Здравствуйте, <Аноним>, Вы писали:

А>Неа. Тот код ждет пока не завершится выполнение метода в другом потоке и потом выходит
Точно, понял.

Здравствуйте, GlebZ, Вы писали:

А почему ты говоришь что оно должно зависнуть?
У меня для 10000 потоков отработало нормально.

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, GlebZ, Вы писали:

А>А почему ты говоришь что оно должно зависнуть?
А>У меня для 10000 потоков отработало нормально.

Там в коде реально баг, и оно может при определнных условиях зависнуть. Может быть ситуация когда поток который выполняет метод DoSmth вызвал PulseAll, но при этом остались потоки, которые еще не вызвали Wait, так вот эти потоки зависнут когда вызовут Wait (если конечно еще раз не вызвать PulseAll).

Здравствуйте, Александр Малафеев, Вы писали:

АМ>Там в коде реально баг, и оно может при определнных условиях зависнуть. Может быть ситуация когда поток который выполняет метод DoSmth вызвал PulseAll, но при этом остались потоки, которые еще не вызвали Wait, так вот эти потоки зависнут когда вызовут Wait (если конечно еще раз не вызвать PulseAll).

Да, теперь вижу.
Тогда опять получается что кроме как с ManualResetEvent это не решить (хотя там тоже, как видно из первого поста не так все гладко).
Где ж 100% солюшн?