Как организовать корректную работу потоков с одним файлом

private void button1_Click(object sender, EventArgs e)
        {
            for (int p = 0; p < 2; p++)
            {
                Thread t = new Thread(pop);
                t.Start();
            }
        }
 
 
 
 
 private void pop()
        {
            var sync = SynchronizationContext.Current;
 
            
                Dictionary<string, string> accounts = new Dictionary<string, string>();
 
                foreach (string combo in File.ReadAllLines("acc.txt"))
                {
                    
                        string[] values = combo.Split(':');
                        if (values.Length >= 2 && !accounts.ContainsKey(values[0]))
                            accounts.Add(values[0], values[1]);
                    
                }
 
                foreach (KeyValuePair<string, string> kvp in accounts)
                {
 
 
                    string email = kvp.Key;
                    string password = kvp.Value;
 
                    string parsmail;
                    parsmail = Regex.Match(email, @"([^>]*)@").Groups[1].Value;
                    string pardomain;
                    pardomain = Regex.Match(email, @"@([^>]*)").Groups[1].Value;
                
                try
                {

 string st;
        private Object lockThis = new Object();
        private void button1_Click(object sender, EventArgs e)
        {
 
            for (int p = 0; p < 2; p++)
            {
                Thread t = new Thread(pop);
                t.Start();
            }
 
 
        }
 
        private void pop()
        {
 
            StreamReader sr = File.OpenText("123.txt");
 
            while (true)
            {
                lock (lockThis)
                {
                    st = sr.ReadLine();
                    if (st == null)
                        break;
                }
                richTextBox1.Invoke((MethodInvoker)delegate { richTextBox1.Text += st + "\n"; });
            }
 
        }

// код
       lock(thisLock)
         {
            list[i]
         }
       // код

StreamReader reader = new StreamReader("proba.txt");
            object thisLock = new object();
            while ((s = reader.ReadLine()) != null)
            {
                lock(thisLock)
                {
                  string[] split = s.Split(';');
                  int x = Int32.Parse(split[0]);
                  int y = Int32.Parse(split[1]);
                  dataGridView1.CurrentCell = dataGridView1.Rows[x].Cells[y];
                  dataGridView1.CurrentCell.Style.BackColor = Color.Red;
                }
            }
            reader.Close();

using System.IO;
using System.Threading;
 
namespace WindowsFormsApplication3
{
    public partial class Form1 : Form
    {
        static object thisLock = new object();
        List<string> list = new List<string>();
        Thread[] potok = new Thread[3];
        Thread th;
 
 
        public Form1()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            string line;
            StreamReader reader = new StreamReader("proba.txt");
            while ((line = reader.ReadLine()) != null)
            {
                string[] split = line.Split('\n');
                list.AddRange(split);
            }
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            string line;
            StreamReader reader = new StreamReader("proba.txt");
            while ((line = reader.ReadLine()) != null)
            {
                string[] split = line.Split('\n');
                list.AddRange(split);
            }
 
 
            for (int i = 0; i < potok.Length; i++)
            {
                potok[i] = new Thread(new ThreadStart(proc));
                potok[i].IsBackground = true;
                Thread.Sleep(1000);
                potok[i].Start();
            }
        }
 
        private void proc()
        {
            int ptr = 0;
            while (ptr < list.Count)
            {
                string curVal;
                lock(thisLock)
                {
                    curVal = list[ptr++];
                }
       
                    if (listBox1.InvokeRequired) listBox1.BeginInvoke(new Action(() => { listBox1.Items.Add(list[curVal] + " // thread number:" + Thread.CurrentThread.ManagedThreadId); }));
                    else listBox1.Items.Add(list[curVal] + " // thread number:" + Thread.CurrentThread.ManagedThreadId);
            }
        }
    }
}

 bool CanRead = false;
        //
        StreamReader sr = null;
        //
        private Object lockThis = new Object();
         
       
        private void button1_Click(object sender, EventArgs e)
        {
            sr = File.OpenText("acc.txt");
            CanRead = true;
            int i = Convert.ToInt32(textBox2.Text);
            
            
            for (int p = 0; p < i; p++)
            {
                Thread t = new Thread(pop);
                t.Start();
                
            }
        }
 
 
 private void pop()
        {
            var sync = SynchronizationContext.Current;
            string st;
            string mail;
            string password;
            string user;
            string domain;
            
 
            while (true)
            {
                lock (lockThis)
                {
 
                    if (CanRead)
                    {
                        
                        st = sr.ReadLine();
                        
                        if (st == null)
                        {
                            CanRead = false;
                            sr.Close();
                            break;
                        }//if (st == null)
 
                        lock (lockThis) textBox1.Invoke((MethodInvoker)delegate { textBox1.Text += st + "\n"; });
                        
                      
                    }//if (CanRead)
 
                    else break;
                }// lock (lockThis)
 
                 try
                    {

struct Account
    {
         //Добавь еще какие тебе нужны поля, если нужны
         public string email;
         public string password;
         public Account(string email, string password)
         {
           this.email = email;
           this.password = password;
         }
}

        Queue<Account> accounts;
        private void LoadAccounts()
        {
            accounts = new Queue<Account>();
            foreach (string line in File.ReadAllLines("acc.txt"))
            {
                string[] data = line.Split(':');
                //Тут тоже надо будет переписать, если нужны какие-то данные кроме мыла
                //и пароля
                Account account = new Account(data[0], data[1]);
                accounts.Enqueue(account);
            }
        }

private void Pop()
        {
            if (accounts.Count == 0)
                return;
            Account account = accounts.Dequeue();
            //Делаешь что хочешь с данными
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading;
 
namespace WindowsFormsApplication2
{
    public class DataAccount
    {
        public string Email { get; set; }
        public string Domain { get; set; }
 
        public DataAccount(string email, string domain)
        {
            Email = email;
            Domain = domain;
        }
    }
 
    public class ParseEventArgs:EventArgs
    {
        public List<DataAccount> Accounts { get; set; }
 
        public ParseEventArgs(List<DataAccount> accounts)
        { Accounts = accounts; }
    }
 
    public class ParserAccounts
    {
        public event EventHandler<ParseEventArgs> Parsed = delegate { };
 
        protected IEnumerable<string> GetFileData(StreamReader reader)
        {
            while (!reader.EndOfStream)
                yield return reader.ReadLine();
        }
 
        protected Match GetMatch(string data, string pattern)
        { return Regex.Match(data, pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase); }
 
        protected string GetValueMatch(string data, string pattern)
        {
            Match match = GetMatch(data, pattern);
            if (match.Success)
                return match.Value;
            return string.Empty;
        }
 
        protected string ParseEmail(string data)
        {
            const string pattern = @"([^>]*)@";
            return GetValueMatch(data, pattern);
        }
 
        protected string ParseDomain(string data)
        {
            const string pattern = @"@([^>]*)";
            return GetValueMatch(data, pattern);
        }
 
        public void Parse(string pathToFile)
        {
            ThreadPool.QueueUserWorkItem((object sender) =>
            {
 
                string email = string.Empty;
                string domain = string.Empty;
                List<DataAccount> accounts = new List<DataAccount>();
                using (StreamReader reader = File.OpenText(pathToFile))
                    foreach (string value in GetFileData(reader))
                    {
                        email = ParseEmail(value);
                        domain = ParseDomain(value);
                        accounts.Add(new DataAccount(email, domain));
                    }
                Parsed(this, new ParseEventArgs(accounts));
            }); 
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading;
 
namespace WindowsFormsApplication2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            ParserAccounts parser = new ParserAccounts();
            parser.Parsed += new EventHandler<ParseEventArgs>(parser_Parsed);
            parser.Parse("account.txt");
        }
 
        void parser_Parsed(object sender, ParseEventArgs e)
        {
            //e.Accounts <- твоя коллекция акков
            //твой код обработки акков
        }
    }
}