Потоки: синхронизированный доступ к стеку

object locker = new object();
List<Something> list = new List<Something>();
 
void MethodThatRunsInThread()
{
   while (true)
   {
      lock (locker) 
         if (list.Count > 0) list.RemoveAt(0);         
      Thread.Sleep(500);
   }
}

 for (int i = 1; i < numericUpDown1.Value; i++)
                {
 
                    Thread thread = new Thread(new ParameterizedThreadStart(axixa));
                    thread.Start(i);
 
                }

 private void axixa()
{
 lock (lockThis)
                {
                    for (int j = 1; j < Convert.ToInt32(textBox1.Text); j++)
                    {
 
                        GetEasylabViews("http:/xxx/search/page" + j");
                        Invoke(new MethodInvoker(() =>
                        {
                            label3.Text = j.ToString();
                        }));
 
                    }
                }
}

 private void GetEasylabViews(string URL)
        {
            string url = URL;
            string html = string.Empty;
            string pattern =("(.*)/profile");
 
            HttpWebRequest myRequest = (HttpWebRequest)HttpWebRequest.Create(url);
            myRequest.AllowAutoRedirect = false;
            HttpWebResponse myResponse = (HttpWebResponse)myRequest.GetResponse();
            StreamReader sr = new StreamReader(myResponse.GetResponseStream(), Encoding.GetEncoding(1251));
            html = sr.ReadToEnd();
 
            var res = Regex.Matches(html, pattern);
 
            foreach (Match match in res)
            {
                var s = match.Value.Remove(0, 2);
                var len = s.Length - s.IndexOf("/");
                Invoke(new MethodInvoker(() =>
                {
                    textBox2.AppendText(s.Remove(s.IndexOf("/"), len));
                    textBox2.Text += Environment.NewLine;
                }));
                
                //MessageBox.Show(match.Value);
            }
 
            //  Console.WriteLine(match.Value);
        }

            HttpWebRequest myRequest = (HttpWebRequest)HttpWebRequest.Create(url);
            myRequest.AllowAutoRedirect = false;
            HttpWebResponse myResponse = (HttpWebResponse)myRequest.GetResponse();
            StreamReader sr = new StreamReader(myResponse.GetResponseStream(), Encoding.GetEncoding(1251));
            html = sr.ReadToEnd();

using System;
using System.Threading;
using System.Collections;
using System.IO;
using System.Diagnostics;
 
namespace ConsApp_MultithreadedParser
{
    class Program
    {
        static void Main(string[] args)
        {
            string txtFile = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), "test.txt");
            string[] lines = System.IO.File.ReadAllLines(txtFile);
 
            Queue queue = new Queue(lines);
            Worker.DoWork(queue, 3);
 
            Console.ReadKey();
        }
    }
}

using System.Collections;
using System.Threading;
using System;
 
namespace ConsApp_MultithreadedParser
{
    public static class Worker
    {
        static object _locker;
        static object _lockerCount;
        static Queue _queue;
 
        /// <summary>
        /// 
        /// </summary>
        /// <param name="queue"></param>
        /// <param name="MaxThreads">Максимальное количество работающих потоков</param>
        public static void DoWork(Queue queue, int MaxThreads)
        {
            _locker = new object();
            _lockerCount = new object();
            _queue = queue;
 
            //финальное кол-во работающих потоков. Если очередь меньше, чем кол-во потоков определённое в константе,
            //то создастся равное размеру очереди кол-во потоков.
            int finalQuantityThreads = _queue.Count < MaxThreads ? _queue.Count : MaxThreads;
 
            //создаём объекты работающие с логинами и паролями в кол-ве равном кол-ву рабочих потоков
            WebSiteParser[] webParsers = new WebSiteParser[finalQuantityThreads];
            Thread[] threads = new Thread[finalQuantityThreads];
 
            for (int i = 0; i < webParsers.Length; i++)
            {
                webParsers[i] = new WebSiteParser(); 
                threads[i] = new Thread(new ParameterizedThreadStart(delegate(object checkerObj)
                        {
                            WebSiteParser webParser = (WebSiteParser)checkerObj;
                            while (GetQueueCount() > 0)
                            {
                                string number = (string)GetObjectFromQueue();
                                if (number != null)
                                    webParser.Parse(new Uri(@"http://zzzzzzz.ru/listing.php/user?us_id=" + number), "<body>(.*?)</body>");
                            }
                        }));
                threads[i].Start(webParsers[i]);
            }
        }
 
        /// <summary>
        /// Получить объект из очереди потокобезопасным методом
        /// </summary>
        /// <returns></returns>
        private static object GetObjectFromQueue()
        {
            lock (_locker)
            {
                if (_queue.Count > 0)
                    return _queue.Dequeue();
                else
                    return null;
            }
        }
 
        /// <summary>
        /// Получить количество элементов в очереди потокобезопасным методом
        /// </summary>
        /// <returns></returns>
        private static int GetQueueCount()
        {
            lock (_lockerCount)
            {
                return _queue.Count;
            }
        }
    }
}

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsApp_Multithreading_UsingTasks
{
    class Program
    {
        // Блокирующая очередь. Сюда будут добавляться "логины" из ричбокса и отсюда их будут доставать обрабатывающие потоки
        static BlockingCollection<int> queue = new BlockingCollection<int>();
 
        static void Main(string[] args)
        {
            // Создаем шесть потоков, которые будут заниматься логином
            Task[] threads = new Task[6];
            for (int i = 0; i < threads.Length; i++)
            {
                int num = i + 1;
                threads[i] = Task.Factory.StartNew(() => ProcessQueue("Thread " + num));
            }
 
            // Создаем очередь "логинов"
            for (int i = 0; i < 100; i++)
            {
                queue.Add(i);
            }
 
            // Эта строчка заставит все слушающие потоки разблокироваться, когда в очереди не останется элементов.
            // На деле ее надо добавлять при завершении работы приложения - чтобы слушающие потоки не висели бесконечно.
            queue.CompleteAdding();
 
            // Ждем окончания работы всех потоков
            Task.WaitAll(threads);
 
            Console.WriteLine("All threads finished execution");
            Console.ReadLine();
        }
 
        // Добавляет элемент в очередь
        static void Enqueue(int value)
        {
            queue.Add(value);
        }
 
        // Удаляет и возвращает первый элемент в очереди
        static int Dequeue()
        {
            return queue.Take();
        }
 
        // Достает элементы из очереди и обрабатывает их
        static void ProcessQueue(object taskName)
        {
 
            while (true)
            {
                try
                {
                    // Достаем следующий элемент из очереди. Если элементов ноль и свойство очереди IsCompleted = false, поток будет заблокирован пока элементы не появятся.
                    int item = Dequeue();
 
                    // Делаем что нам нужно. В данном случае просто выводим полученный из очереди элемент в консоль. На деле здесь будут обрабатываться логины.
                    Console.WriteLine("{0}: processing {1}.", taskName, item);
 
                    // Допустим, один логин занимает 1 секунду.
                    Thread.Sleep(1000);
                }
                catch (InvalidOperationException)
                {
                    // Обеспечиваем выход из бесконечного цикла при завершении работы приложения
                    Console.WriteLine("{0} has finished working", taskName);
                    return;
                }
            }
        }
    }
}

 static void ProcessQueue(object taskName)
        {
 
            while (true)
            {
                try
                {
                    
                    int item = Dequeue();
 
                  
                    Console.WriteLine("{0}: processing {1}.", taskName, item);
                    textBox2.AppendText(taskname);  // к[B]ак получить доступ к элементу формы *[/B]
 
                    
                    Thread.Sleep(1000);
                }
                catch (InvalidOperationException)
                {
                    
                    Console.WriteLine("{0} has finished working", taskName);
                    return;
                }
            }