How do you ensure thread-safe access when multiple threads are writing to the same file?

Question

ICSM Computer · Answer

To ensure thread-safe access when multiple threads write to the
same file in C#, you must synchronize access to prevent race conditions, data corruption, or file lock exceptions.
Here are several approaches:
1. Use a lock for synchronization
Ensure only one thread writes at a time:
private static readonly object fileLock = new object();
public static void WriteToFile(string path, string text)
{
    lock (fileLock)
    {
        File.AppendAllText(path, text + Environment.NewLine);
    }
}
2. Use ConcurrentQueue with a background writer thread
This pattern allows threads to enqueue write requests, and a single thread handles the file writes.
private static readonly ConcurrentQueueandlt;stringandgt; logQueue = new ConcurrentQueueandlt;stringandgt;();
private static readonly AutoResetEvent logSignal = new AutoResetEvent(false);
private static readonly string logFilePath = "log.txt";
public static void StartLogger()
{
    Task.Run(() =andgt;
    {
        while (true)
        {
            logSignal.WaitOne();  // Wait for signal
            while (logQueue.TryDequeue(out string? line))
            {
                File.AppendAllText(logFilePath, line + Environment.NewLine);
            }
        }
    });
}
public static void Log(string message)
{
    logQueue.Enqueue(message);
    logSignal.Set();  // Signal the logger
}
3. Use SemaphoreSlim for async scenarios
private static readonly SemaphoreSlim fileSemaphore = new SemaphoreSlim(1, 1);
public static async Task WriteToFileAsync(string path, string text)
{
    await fileSemaphore.WaitAsync();
    try
    {
        await File.AppendAllTextAsync(path, text + Environment.NewLine);
    }
    finally
    {
        fileSemaphore.Release();
    }
}
What to avoid:
Writing to the same file from multiple threads without coordination (e.g., no lock, no queue).Opening the file in append mode from multiple places simultaneously.

interview

How do you ensure thread-safe access when multiple threads are writing to the same file?

ICSM Computer

Can you answer this question?

1 Answers

1. Use a `lock` for synchronization

2. Use `ConcurrentQueue` with a background writer thread

3. Use `SemaphoreSlim` for async scenarios

What to avoid:

Liked By