Любые проблемы параллелизма с моим кодом

Question

Я пытаюсь создать поточно-безопасный метод.

Кто-нибудь видит проблемы параллелизма со следующим кодом?

Мне кажется, что это нормально, , хотя я никогда не мог найти способ проверить параллельность этого метода. Любая помощь будет оценена по достоинству.

//static locker for thread synchronization 
    private static readonly System.Object _object3 = new System.Object(); 

    //this method needs to be thread-safe 
    public static void LogToTextFile(string logMessage, LogLevel logType) 
    { 
     //make sure only one thread executes this file writing code at a time    
     lock (_object3) 
     { 
      using (StreamWriter w = File.AppendText(@"c:\logs\log1.txt"); 
      { 
       w.WriteLine("\r\n{0} logged at {1} {2} : {3}", logType.ToString().ToUpper(), DateTime.Now.ToLongTimeString(), DateTime.Now.ToLongDateString(), logMessage); 
      } 
     } 
    } 

Answer 1

Там нет параллельности проблем с этим кодом, потому что вы позволяете только один поток для записи в файл из-за блокировки заявления.

Answer 2

Учитывая, что у вас есть lock вокруг объекта с соответствующей областью, я не вижу проблем с параллелизмом с вашим кодом.

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

Если я упоминаю проблему, вам придется реализовать более сложный потокобезопасный регистратор. Как правило, будет очередь, в которой записываются события журнала. Затем есть еще один поток, который периодически просыпается и опустошает очередь на файл на диске. Все операции в очереди выполняются с помощью блокировки.

Answer 3

Другим, возможно, лучшим решением может стать оставить файл открытым и использовать синхронизированный TextWriter для выполнения операций записи. TextWriter.Synchronized обеспечивает поточно-обертку вокруг TextWriter:

Все операции записи возвращенного обертке будет поточно. Вы вызываете этот метод, чтобы гарантировать, что только один поток за раз может выполнить методы экземпляра TextWriter, который возвращается.

Вот простая реализация. Обратите внимание, что это не было протестировано.

public static class MyLogger 
{ 
    private static TextWriter s_writer; 

    // Not thread-safe. Call this before other threads are allowed to call Log. 
    public void Open(string filename) { 
     s_writer = TextWriter.Synchronized(File.AppendText(filename)); 
    } 

    // Also not thread-safe. 
    public void Close() { 
     s_writer.Dispose(); 
    } 

    // Thread-safe. 
    public void Log(string logMessage, LogLevel logType) { 
     s_writer.WriteLine("\r\n{0} logged at {1} {2} : {3}", 
      logType.ToString().ToUpper(), DateTime.Now.ToLongTimeString(), 
      DateTime.Now.ToLongDateString(), logMessage); 
    }  
} 

Answer 4

В этой конкретной функции отсутствуют проблемы параллелизма. Оператор lock будет правильно умерить доступ ко внутреннему коду.

Однако по-прежнему существуют проблемы с параллелизмом при доступе к @"c:\logs\log1.txt". Возможно, что другая часть вашего приложения или другой процесс на том же компьютере попытается записать файл в то же время, что и ваш код. Следовательно, возможно, код StreamWriter не удастся даже с этой блокировкой.

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

Как правило, при работе с функциями регистрации я обертываю доступ к файловой системе с помощью try/catch и проглатываю все возникающие исключения. В противном случае вы рискуете от сбоя функции регистрации, сняв приложение. Это может быть или не быть приемлемым для вашего сценария.