Синхронизация нескольких потоков

Barrier barrier = new Barrier(2); // 2 = #threads participating.
            bool complete = false;
            TaskFactory factory = Task.Factory;
 
            // Start tasks
            Task task_1 = factory.StartNew(() =>
            {
                process_1.Server("1 and 2");
                barrier.SignalAndWait(); // Wait for task 2 to catch up.
                barrier.SignalAndWait(); // Wait for task 2 to print "2" and set complete = true.
 
                if (complete)
                {
                    process_1.Server("1 and 3");
                }
            });
            Task task_6 = factory.StartNew(() =>
            {
                process_6.Server("6 and 4");
                process_6.Server("6 and 3");
            });
            Task task_2 = factory.StartNew(() =>
            {
                barrier.SignalAndWait(); // Wait for task 1 to print "1".
                process_2.Client("1 and 2");
                complete = true;
                barrier.SignalAndWait(); // Wait for task 1 to read complete as true.
 
                process_2.Server("2 and 5");
                process_2.Server("2 and 3");
            });
            Task task_4 = factory.StartNew(() =>
            {
                process_4.Client("6 and 4");
                process_4.Server("4 and 7");
                process_4.Server("4 and 3");
            });
            Task task_5 = factory.StartNew(() =>
            {
                process_5.Client("2 and 5");
                process_5.Server("5 and 3");
            });
            Task task_7 = factory.StartNew(() =>
            {
                process_7.Client("4 and 7");
                process_7.Server("7 and 3");
            });
            Task task_3 = factory.StartNew(() =>
            {
                process_3.Client("1 and 3");
                process_3.Client("2 and 3");
                process_3.Client("4 and 3");
                process_3.Client("5 and 3");
                process_3.Client("6 and 3");
                process_3.Client("7 and 3");
            });
 
            task_3.Wait();

process_1.Server("1 and 2");

process_2.Client("1 and 2");

List<Task> ListTask = new List<Task>();
 
            Task task_1 = new Task(() =>
            {
                process_1.Server("1 and 2");
                //.....
            });
 
            Task task_2 = new Task(() =>
            {
                process_2.Client("1 and 2");
                //....
             });
            ListTask.Add(task_1);
            ListTask.Add(task_2);
 
            ListTask[0].Start();
            Task.WaitAny(ListTask[0]);
            ListTask[1].Start();

public void Server(object pipeName)
        {
            // Create a name pipe
            using (NamedPipeServerStream pipeStream = new NamedPipeServerStream(pipeName.ToString()))
            {
                // Wait for a connection
                pipeStream.WaitForConnection();
 
                using (StreamWriter sw = new StreamWriter(pipeStream))
                {
                    sw.AutoFlush = true;
                    sw.WriteLine(message);
                }
                //pipeStream.Close();
                Console.Write("Communication between processes " + pipeName.ToString());
            }
        }
 
        public void Client(object pipeName)
        {
            using (NamedPipeClientStream pipeStream = new NamedPipeClientStream(pipeName.ToString()))
            {
                // The connect function will indefinately wait for the pipe to become available
                // If that is not acceptable specify a maximum waiting time (in ms)
                pipeStream.Connect();
 
                using (StreamReader sr = new StreamReader(pipeStream))
                {
                    // We read a line from the pipe and print it together with the current time
                    message += sr.ReadLine();
                }
                //pipeStream.Connect();
                Console.WriteLine(": client received message.\n");
            }
        }

 Server(object pipeName)
{
//....
Client(object pipeName)
}