Execute error для не синхронизированного блока кода вызван метод синхронизации объектов

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

class Program
    {
        static Mutex mutexObj = new Mutex();
     
        static int sizefile = 0;
        static int iter = 0;
        static string[] file;
        static void Main(string[] args)
        {
            countline();
            file = new string[sizefile];
            string text = null;
            using (StreamReader sr = new StreamReader("B.txt", System.Text.Encoding.Default))
            {
                for (int i = 0; i < file.Length; i++)
                {
                    text = sr.ReadLine();
                    file[i] = text;
                }
            }
            Thread myThread;
            
            myThread = new Thread(PersonalWrite);
            myThread.Start();
            Thread myThread2 = new Thread(ProgramWrite);
            myThread2.Start();
            
            //Console.ReadLine();
        }
 
       
        public static void PersonalWrite()
        {
            mutexObj.WaitOne();
            string text = "";
 
            do
            {
                Console.WriteLine("Enter text: (if need close programm enter 'exit')");
                text = Console.ReadLine();
                using (StreamWriter sw = new StreamWriter("A.txt", true, System.Text.Encoding.Default))
                {
                    sw.WriteLine(text);
                }
                mutexObj.ReleaseMutex();
            }
            while (text != "exit");
            return;
        }
 
        static void countline()
        {
            using (StreamReader sr = new StreamReader("B.txt", System.Text.Encoding.Default))
            {
                int nline = 0;
                while ((sr.ReadLine()) != null)
                {
                    nline++;
                }
                sizefile = nline;
            }
        }
 
 
        public static void ProgramWrite()
        {
            mutexObj.WaitOne();
 
            string text = file[iter];
            
            using (StreamWriter sw = new StreamWriter("A.txt", true, System.Text.Encoding.Default))
            {
                sw.WriteLine(text);
                iter++;
            }
            mutexObj.ReleaseMutex();
        }
 
       
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

class Program
    {
        static Mutex mutexObj = new Mutex();
     
        static void Main(string[] args)
        {
            Thread myThread = new Thread(PersonalWrite); 
            myThread.Start();
            myThread = new Thread(ProgramWrite); 
            myThread.Start();
        }
 
       
        public static void PersonalWrite()
        {
            string text = "";
            while (true)
            {
                mutexObj.WaitOne();
                Console.WriteLine("Enter text: (if need close programm enter 'exit')");
                text = Console.ReadLine();
                if(text == "exit")
                    return;
                using (StreamWriter sw = new StreamWriter("A.txt", true, System.Text.Encoding.Default))
                {
                    sw.WriteLine(text);
                }
                mutexObj.ReleaseMutex();
            }
            
        }
 
        public static void ProgramWrite()
        {
            using (StreamReader sr = new StreamReader("B.txt", System.Text.Encoding.Default))
            {
                while ((sr.ReadLine()) != null)
                {
                    mutexObj.WaitOne();
                    using (StreamWriter sw = new StreamWriter("A.txt", true, System.Text.Encoding.Default))
                    {
                        sw.WriteLine(sr.ReadLine());
                    }
                    mutexObj.ReleaseMutex();
 
                }
            }
        }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

class Program
    {
        static Mutex mutexObj1 = new Mutex(false);
        static Mutex mutexObj2 = new Mutex(true);
 
        static void Main(string[] args)
        {
            Thread myThread = new Thread(PersonalWrite); 
            myThread.Start();
            myThread = new Thread(ProgramWrite); 
            myThread.Start();
        }
 
       
        public static void PersonalWrite()
        {
            string text = "";
            while (true)
            {
                mutexObj2.WaitOne();
                Console.WriteLine("Enter text: (if need close programm enter 'exit')");
                text = Console.ReadLine();
                if(text == "exit")
                    return;
                using (StreamWriter sw = new StreamWriter("A.txt", true, System.Text.Encoding.Default))
                {
                    sw.WriteLine(text);
                }
                mutexObj1.ReleaseMutex();
            }
            
        }
 
        public static void ProgramWrite()
        {
            using (StreamReader sr = new StreamReader("B.txt", System.Text.Encoding.Default))
            {
                while ((sr.ReadLine()) != null)
                {
                    mutexObj1.WaitOne();
                    using (StreamWriter sw = new StreamWriter("A.txt", true, System.Text.Encoding.Default))
                    {
                        sw.WriteLine(sr.ReadLine());
                    }
                    mutexObj2.ReleaseMutex();
                }
            }
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

class Program
    {
        static Mutex mutexObj1 = new Mutex(true);
        static Mutex mutexObj2 = new Mutex(false);
        static StreamWriter streamWriter = new StreamWriter("A.txt", false, System.Text.Encoding.Default);
        static void Main(string[] args)
        {
            Thread myThread = new Thread(PersonalWrite);
            myThread.Start();
            myThread = new Thread(ProgramWrite);
            myThread.Start();
        }
        
 
        public static void PersonalWrite()
        {
            string text = "";
            while (true)
            {
                mutexObj1.WaitOne();
                Console.WriteLine("Enter text: (if need close programm enter 'exit')");
                text = Console.ReadLine();
                if(text == "exit")
                    return;
                streamWriter.WriteLine(text);
                mutexObj2.ReleaseMutex();
            }
            
        }
 
        public static void ProgramWrite()
        {
            using (StreamReader sr = new StreamReader("B.txt", System.Text.Encoding.Default))
            {
                while ((sr.ReadLine()) != null)
                {
                    mutexObj2.WaitOne();
                    streamWriter.WriteLine(sr.ReadLine());
                    mutexObj1.ReleaseMutex();//"Для не синхронизированного блока кода вызван метод синхронизации объектов."
                }
            }
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

void Main()
{
    var cts = new CancellationTokenSource();
 
    Console.CancelKeyPress += (_, ccea) =>
    {
        cts.Cancel();
        ccea.Cancel = true;
    };
    Task.Run(() =>
    {
        var lines = ConcatLines(
                   File.ReadLines(@"C:UserspzixeDesktop1.txt"), 
                   File.ReadLines(@"C:UserspzixeDesktop2.txt"));
        foreach (var line in lines)
        {
            if (cts.IsCancellationRequested)
            {
                return;
            }
            Console.WriteLine(line);
        }
        cts.Cancel();
    });
    
    cts.Token.WaitHandle.WaitOne();
}
 
IEnumerable<string> ConcatLines(IEnumerable<string> fileA, IEnumerable<string> fileB) => 
    fileA.Zip(fileB, (a, b) => new[] {a, b}).SelectMany(x => x);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

    private enum Worker
    {
      Console,
      File,
      Main
    }
 
    private class ThreadState
    {
      public StreamWriter FileA { get; private set; }
      public Mutex Mutex { get; private set; }
      public Worker CurrentWorker { get; set; }
 
      public ThreadState(StreamWriter fileA, Mutex mutex)
      {
        FileA = fileA;
        Mutex = mutex;
        CurrentWorker = Worker.Console;
      }
    }
    
    private static Thread _consoleThread;
    private static Thread _fileThread;
 
    static void Main()
    {
      using (var writer = new StreamWriter(@"D:A.txt", false, System.Text.Encoding.Default))
      {
        var mutex = new Mutex(false);
        var state = new ThreadState(writer, mutex);
 
        _consoleThread = new Thread(ConsoleWrite);
        _consoleThread.IsBackground = true;
        _consoleThread.Start(state);
 
        _fileThread = new Thread(FileWrite);
        _fileThread.IsBackground = true;
        _fileThread.Start(state);
 
        while (true)
        {
          state.Mutex.WaitOne();
          try
          {
            if (state.CurrentWorker == Worker.Main)
              return;
          }
          finally
          {
            state.Mutex.ReleaseMutex();
          }
        }
      }
    }
 
    private static void ConsoleWrite(object state)
    {
      var threadState = (ThreadState)state;
      while (true)
      {
        threadState.Mutex.WaitOne();
        try
        {
          if (threadState.CurrentWorker == Worker.Console)
          {
            var line = Console.ReadLine();
            if (line == "exit")
            {
              threadState.CurrentWorker = Worker.Main;
              return;
            }
              
            threadState.FileA.WriteLine(line);
            threadState.CurrentWorker = Worker.File;
          }
        }
        finally
        {
          threadState.Mutex.ReleaseMutex();
        }
      }
    }
 
    private static void FileWrite(object state)
    {
      var threadState = (ThreadState)state;
      using (var reader = File.OpenText(@"D:B.txt"))
      {
        while (true)
        {
          threadState.Mutex.WaitOne();
          try
          {
            if (threadState.CurrentWorker == Worker.File)
            {
              var line = reader.ReadLine();
              if (line == null)
              {
                threadState.CurrentWorker = Worker.Main;
                return;
              }
 
              threadState.FileA.WriteLine(line);
              threadState.CurrentWorker = Worker.Console;
            }
          }
          finally
          {
            threadState.Mutex.ReleaseMutex();
          }
        }
      }
    }