以线程安全的方式写入文件

Question

将Stringbuilder 异步写入文件。此代码控制一个文件，向其中写入一个流并释放它。它处理来自异步操作的请求，这些请求可能随时进来。

FilePath 是针对每个类实例设置的（因此锁定 Object 是针对每个实例的），但由于这些类可能共享 FilePaths，因此存在潜在的冲突。这种冲突，以及来自类实例之外的所有其他类型，都将通过重试来处理。

此代码是否适合其用途？有没有更好的方法来处理这个问题，这意味着更少（或不）依赖捕获和重试机制？

还有我如何避免捕获因其他原因而发生的异常。

public string Filepath { get; set; }
private Object locker = new Object();

public async Task WriteToFile(StringBuilder text)
    {
        int timeOut = 100;
        Stopwatch stopwatch = new Stopwatch();
        stopwatch.Start();
        while (true)
        {
            try
            {
                //Wait for resource to be free
                lock (locker)
                {
                    using (FileStream file = new FileStream(Filepath, FileMode.Append, FileAccess.Write, FileShare.Read))
                    using (StreamWriter writer = new StreamWriter(file, Encoding.Unicode))
                    {
                        writer.Write(text.ToString());
                    }
                }
                break;
            }
            catch
            {
                //File not available, conflict with other class instances or application
            }
            if (stopwatch.ElapsedMilliseconds > timeOut)
            {
                //Give up.
                break;
            }
            //Wait and Retry
            await Task.Delay(5);
        }
        stopwatch.Stop();
    }

Answer 1

您如何处理这在很大程度上取决于您的写作频率。如果您不经常编写相对少量的文本，那么只需使用静态锁即可。无论如何，这可能是您最好的选择，因为磁盘驱动器一次只能满足一个请求。假设你所有的输出文件都在同一个驱动器上（也许不是一个公平的假设，但请容忍我），在应用程序级别的锁定和在操作系统级别完成的锁定之间不会有太大的区别。

因此，如果您将locker 声明为：

static object locker = new object();

您可以放心，您的程序中不会与其他线程发生冲突。

如果您希望这个东西是防弹的（或至少合理地如此），您就无法避免捕获异常。坏事可能发生。您必须以某种方式处理异常。你在面对错误时所做的完全是另一回事。如果文件被锁定，您可能需要重试几次。如果您收到错误的路径或文件名错误或磁盘已满或任何其他错误，您可能想要终止该程序。再次，这取决于你。但是你无法避免异常处理，除非你可以接受程序因错误而崩溃。

顺便说一句，您可以替换所有这些代码：

                using (FileStream file = new FileStream(Filepath, FileMode.Append, FileAccess.Write, FileShare.Read))
                using (StreamWriter writer = new StreamWriter(file, Encoding.Unicode))
                {
                    writer.Write(text.ToString());
                }

只需一次调用：

File.AppendAllText(Filepath, text.ToString());

假设您使用的是 .NET 4.0 或更高版本。见File.AppendAllText。

您可以处理此问题的另一种方法是让线程将其消息写入队列，并有一个专用线程为该队列提供服务。你会有一个BlockingCollection 的消息和相关的文件路径。例如：

class LogMessage
{
    public string Filepath { get; set; }
    public string Text { get; set; }
}

BlockingCollection<LogMessage> _logMessages = new BlockingCollection<LogMessage>();

您的线程将数据写入该队列：

_logMessages.Add(new LogMessage("foo.log", "this is a test"));

您启动了一个长时间运行的后台任务，该任务只为队列提供服务：

foreach (var msg in _logMessages.GetConsumingEnumerable())
{
    // of course you'll want your exception handling in here
    File.AppendAllText(msg.Filepath, msg.Text);
}

这里的潜在风险是线程创建消息的速度太快，导致队列无限制地增长，因为消费者跟不上。这是否是您的应用程序中的真正风险，只有您可以说。如果您认为这可能存在风险，您可以在队列中设置一个最大大小（条目数），这样如果队列大小超过该值，生产者将等到队列中有空间后才能添加。

Answer 2

您也可以使用ReaderWriterLock，它被认为是在处理读写操作时控制线程安全的更“合适”的方式...

为了调试我的网络应用程序（当远程调试失败时），我使用以下命令（'debug.txt' 最终位于服务器上的 \bin 文件夹中）：

public static class LoggingExtensions
{
    static ReaderWriterLock locker = new ReaderWriterLock();
    public static void WriteDebug(string text)
    {
        try
        {
            locker.AcquireWriterLock(int.MaxValue); 
            System.IO.File.AppendAllLines(Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase).Replace("file:\\", ""), "debug.txt"), new[] { text });
        }
        finally
        {
            locker.ReleaseWriterLock();
        }
    }
}

希望这可以为您节省一些时间。