Multithreading lock read/write text c#

Question

After a lot of research, and after reading and trying all of the questions on here, I think it's time for me to ask for some help.

I have an application in C#, and I'm trying to write in the SAME file with different thread.

public static void LaunchThreads(string path_file)
{
    int i = 0;
    Dictionary<int, Thread> threadsdico = new Dictionary<int, Thread>();
    while (i < MAX_THREAD)
    {
            Thread thread = new Thread(() => ThreadEntryWriter(string path_file));
            thread.Name = string.Format("ThreadsWriters{0}", i);
            threadsdico.Add(i, thread);
            thread.Start();
            i++;
    }
    int zz = 0;
    while (zz < threadsdico.Count())
    {
        threadsdico[zz].Join();
        zz++;
    }
}
private static readonly Object obj = new Object();
public static void ThreadEntryWriter(string path_file)
{
    int w = 0;
    while (w < 99)
    {       
        string newline = w + " - test" + "\r";
        lock(obj)
        {
            string txt = File.ReadAllText(path_file);
            using (TextWriter myWriter = new StreamWriter(path_file))
            {   
                TextWriter.Synchronized(myWriter).Write(txt + newline);
            }
        }
        w++;
    }
}

I've try everything, my code is globally like that, but I've try every way, with every lock, every file open method, but I keep getting The process cannot access the files because it's in use. The line who generate this error is this one using (TextWriter myWriter = new StreamWriter(path_file)).

I tried a lot of thing, closing the files etc, but when threads start to work at the same time, the program stop and give me the error The process cannot access the files because it's in use (self-explain). But I don't understand why, the lock is suppose to block another thread to enter here. And I used Synchronized method to write which is thread safe. Well sorry for the long writing it's my first post here.

Answer 1

Synchronized writer still should be disposed:

var newline = w + " - test";
using (var sw = new StreamWriter(path_file))
using (var sync = TextWriter.Synchronized(sw))
{
    // no need to add a new line char, just use other method to write
    sync.WriteLine(txt + newline);
}

Also, you can save a sync variable and call it's methods from all the threads, and it will do all the work for you, and you can dispose it later after all the text is written.

Answer 2

I test your code and applied some changes and it's working fine without error.

I used winform application to run your code.Please check below code.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApplication14
{
    public partial class Form1 : Form
    {
        private readonly Object obj = new Object();

        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
        }

        private void button1_Click(object sender, EventArgs e)
        {
            LaunchThreads("D:\\log.txt");
        }

        public void LaunchThreads(string path_file)
        {
            int i = 0;
            int MAX_THREAD = 10;
            Dictionary<int, Thread> threadsdico = new Dictionary<int, Thread>();
            while (i < MAX_THREAD)
            {
                Thread thread = new Thread(() => ThreadEntryWriter(path_file, string.Format("ThreadsWriters{0}", i)));
                    thread.Name = string.Format("ThreadsWriters{0}", i);
                    threadsdico.Add(i, thread);
                    thread.Start();
                    i++;
            }
            int zz = 0;
            while (zz < threadsdico.Count())
            {
                threadsdico[zz].Join();
                zz++;
            }
        }

        public void ThreadEntryWriter(string path_file,string threadName)
        {
            int w = 0;
            while (w < 99)
            {
                string newline = w + " - test" + " Thread:" + threadName + "\r\n";
                lock (obj)
                {
                    string txt = File.ReadAllText(path_file);
                    using (TextWriter myWriter = new StreamWriter(path_file))
                    {
                        TextWriter.Synchronized(myWriter).Write(txt + newline);
                    }
                }
                w++;
            }
        }
    }
}

I got output as below.

• 0 - test Thread:ThreadsWriters1
• 0 - test Thread:ThreadsWriters2
• 1 - test Thread:ThreadsWriters2
• 2 - test Thread:ThreadsWriters2
• 1 - test Thread:ThreadsWriters1
• ....
• ....

Answer 3

It seems like you want to write lines to the same file from multiple threads.

It's quite inefficient to read in all lines every time you want to output a line and then append a line and write it out.

I think the cause of your error is that you aren't disposing the Synchronized TextWriter, so it may well be keeping a reference to the file open even though you dispose the underlying TextWriter.

It's also redundant to use your own locking and the Synchronized TextWriter.

I have changed your code a bit to share a single Synchronized TextWriter and just append lines rather than reading the whole file, appending and then writing it out:

    public static void LaunchThreads(string path_file)
    {
        int i = 0;
        using(var sw = File.CreateText(path_file))
        using(var syncWriter = TextWriter.Synchronized(sw)) 
        {
            Dictionary<int, Thread> threadsdico = new Dictionary<int, Thread>();
            while (i < MAX_THREAD)
            {
                Thread thread = new Thread(() => ThreadEntryWriter(syncWriter));
                thread.Name = string.Format("ThreadsWriters{0}", i);
                threadsdico.Add(i, thread);
                thread.Start();
                i++;
            }
            int zz = 0;
            while (zz < threadsdico.Count())
            {
                threadsdico[zz].Join();
                zz++;
            }
        }
    }

    public static void ThreadEntryWriter(TextWriter writer)
    {
        int w = 0;
        while (w < 99)
        {       
            writer.WriteLine($"{w} - test");
            w++;
        }
    }