Как оптимизировать запись в несколько файлов в фоновом режиме

Question

Моя программа должна часто писать сообщения нескольким файлам. Поскольку это очень много времени, мне нужно его оптимизировать. Ниже вы можете найти извлечение из моей программы, где я пытаюсь записать async в файл в фоновом режиме. Кажется, что это работает, но я не уверен, что это лучшая практика, поскольку я не распоряжаюсь задачами (эта часть прокомментирована). Я не делаю этого, потому что не хочу, чтобы моя программа дождалась завершения этих задач. Просто я хочу, чтобы мое сообщение было написано на несколько файлов в фоновом режиме как можно быстрее. Поскольку к этим файлам можно было обращаться несколькими потоками, я добавил блокировку. Я использую статические методы, потому что эти методы используются везде в моем коде, и я не хочу создавать экземпляр этого класса, просто чтобы написать одну строку сообщения в файл везде (возможно, это неправильно).

================= Класс =========================================================== ===================

namespace test 
{ 

    public static class MessageLOG 
    { 
    private static string debugFileName   = Settings.DebugLOGfilename; 
    private static string logFileName   = Settings.LOGfilename; 
    private static object DebuglockOn = new object(); 
    private static object LoglockOn  = new object(); 
    private static StreamWriter DebugSW; 
    private static StreamWriter LogSW; 

    private static void DebugFile(string message) 
    {   
     uint linesCount = 0; 
     string _filename = debugFileName; 

     if(DebugSW == null && !string.IsNullOrEmpty(_filename)) 
      DebugSW = new StreamWriter(_filename); 


     if(DebugSW != null)     
     { 
      lock(DebuglockOn) 
      { 
       DebugSW.WriteLine(message); 
       linesCount++; 
       if (linesCount > 10) 
       { 
        DebugSW.Flush(); 
        linesCount = 0; 
       }       
      }     
     }     
    } 

    private static void LogFile(string message) 
    { 
     uint linesCount = 0; 
     string _filename = logFileName; 

     if(LogSW == null && !string.IsNullOrEmpty(_filename)) 
      LogSW = new StreamWriter(_filename); 


     if(LogSW != null)     
     { 
      lock(LoglockOn) 
      { 
       LogSW.WriteLine(string.Format("{0} ({1}): {2}", DateTime.Now.ToShortDateString(), DateTime.Now.ToShortTimeString(), message)); 
       linesCount++; 
       if (linesCount > 10) 
       { 
        LogSW.Flush(); 
        linesCount = 0; 
       } 
      }     
     } 


     public static void LogUpdate(string message) 
     { 
      ThreadPool.QueueUserWorkItem(new WaitCallback((x) => LogFile(message))); 
      ThreadPool.QueueUserWorkItem(new WaitCallback((x) => DebugFile(message))); 
      ThreadPool.QueueUserWorkItem(new WaitCallback((x) => Debug.WriteLine(message))); 
     } 
//This method will be called when the main thread is being closed 
     public static void CloseAllStreams() 
     { 
      if (DebugSW != null) 
      { 
       DebugSW.Flush(); 
       DebugSW.Close(); 
      } 

      if (LogSW != null) 
      { 
       LogSW.Flush(); 
       LogSW.Close(); 
      }  
     } 

=============== main window =========== 
void MainWIndow() 
{ 
... some code .... 

MessageLog.LogUpdate("Message text"); 
... code cont .... 

MessageLog.CloseAllStreams(); 
} 

Answer 1

You're открытие нового потока и совершение письмен для каждого действия записи: очень плохого производительности.

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

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

Также периодически, возможно, каждый X-номер записи, вы можете сделать Stream.Flush для фиксации записей на диске. Этот флеш должен быть защищен замком.

Answer 2

Вы должны подумать о своем дизайне. Ваши блокировки не должны быть локальными переменными в вашем методе. Это избыточно, потому что каждый вызов метода создает новый объект и блокирует его. Это не приведет к синхронизации синхронизации по нескольким потокам (https://msdn.microsoft.com/en-us/library/c5kehkcz(v=vs.80).aspx). Поскольку ваши методы являются статическими, блокировки должны быть статическими переменными, и у вас должна быть отдельная блокировка для каждого файла. Вы можете использовать ThreadPool.QueueUserWorkItem (https://msdn.microsoft.com/en-us/library/kbf0f1ct(v=vs.110).aspx) вместо задач. ThreadPool - это внутренний класс .NET, который повторно использует потоки для выполнения асинхронных операций. Это идеально подходит для вашего случая использования, потому что вам не нужен контроль над каждым потоком. Вам просто нужна операция async для выполнения и завершения самостоятельно.

Лучшим подходом было бы создать класс регистратора, который запускается в своем потоке. Вы можете иметь очереди и помещать в очередь сообщения из нескольких потоков, а затем записывать дескриптор LoggerThread в файл. Это обеспечит запись только одного потока в файл. Это также будет поддерживать порядок ведения журнала, если вы используете очередь FIFO. Вам больше не нужно будет блокировать запись в файл, но вам нужно будет заблокировать вашу очередь. Вы можете использовать класс .NET Monitor (https://msdn.microsoft.com/en-us/library/system.threading.monitor(v=vs.110).aspx) для блокировки LoggerThread до тех пор, пока сообщение не будет поставлено в очередь (посмотрите на методы Enter/Wait/Pulse). Чтобы еще больше оптимизировать его, теперь вы можете держать поток открытым для файла и нажимать на него данные, поскольку он попадает в очередь. Поскольку только один поток когда-либо обращается к файлу, это будет ОК. Не забудьте закрыть поток в файл, когда закончите. Вы также можете настроить таймер, который отключается один раз в то время, чтобы очистить содержимое. Не рекомендуется поддерживать открытый поток, особенно если вы ожидаете, что другие приложения попытаются заблокировать файл. Однако в этом случае это может быть ОК. Это будет дизайнерское решение, которое вам нужно сделать, чтобы оно соответствовало вашему приложению.