Question

我的程序需要经常将消息写入多个文件。由于非常耗时，我需要对其进行优化。下面，你可以从我的程序中找到一个摘录，我尝试在后台写异步到文件。它似乎有效，但我不确定这是否是最好的做法，因为我没有处理任务（这部分是评论）。我不这样做，因为我不希望我的程序等待那些任务完成。简单地说，我希望我的消息尽快写入后台的少量文件。由于这些文件可以被多个线程访问，我添加了锁。我使用静态方法，因为这些方法在我的代码中无处不在，我不想实例化这个类，只是在一个地方写一行消息到文件（可能那个错误）。

================== Class ============================ ==================

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

你应该重新考虑你的设计。您的锁不应该是方法中的局部变量。这是多余的，因为每个方法调用都会创建一个新对象并锁定它。这不会强制跨多个线程（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）代替Tasks。 ThreadPool是一个内部.NET类，它重用线程来运行异步操作。这非常适合您的用例，因为您不需要控制每个线程。您只需要一些异步操作来自行执行和完成。

更好的方法是创建一个在自己的线程上运行的记录器类。您可以拥有一个队列并将来自多个线程的消息排入队列，然后让LoggerThread句柄写入该文件。这将确保只有一个线程写入文件。如果使用FIFO队列，这也将保持记录顺序。您将不再需要锁定写入文件，但您需要锁定队列。您可以使用.NET Monitor（https://msdn.microsoft.com/en-us/library/system.threading.monitor(v=vs.110).aspx）类来阻止LoggerThread，直到消息排队（查看方法Enter / Wait / Pulse）。为了进一步优化它，您现在可以保持对文件打开的流，并在排队时将数据推送到该文件。由于只有一个线程可以访问该文件，因此可以。只需记住在完成后关闭文件流。您还可以设置一个计时器，该计时器偶尔会关闭以刷新内容。保持流打开并不总是建议，特别是如果您预计其他应用程序试图锁定文件。但是，在这种情况下，它可能没问题。这将是您需要做出的最适合您的应用程序的设计决策。

Answer 2

您为每个写操作打开一个新流并提交着作：性能非常差。

我的建议是每个文件只使用一个StreamWriter，这个实例必须是一个类字段，你需要仍然使用锁来确保线程安全。

此外，这还要求您不要在每个写入方法中使用using语句。

也可以定期，也许每X次写入，你可以让Stream.Flush在磁盘上提交文字。此冲洗必须由锁保护。

如何在后台优化写入多个文件

2 个答案: