Синхронизация потоков

using System;
using System.Collections.Generic;
 
namespace ConsoleTest
{
    public class Program
    {
        private static void QueueSSS_OnMessage(object sender, string message)
        {
            Console.WriteLine(sender.ToString() + ": " + message);
        }
 
        public static void Main()
        {
            QueueSSS que = new QueueSSS();
            que.OnMessage += QueueSSS_OnMessage;
 
            for (int i = 0; i < 3; i++)
                que.AddQueuer(i);
 
            que.Start();
            Console.ReadLine();
 
            que.Stop();
            Console.ReadLine();
        }
    }
 
    public delegate void StringHandler(object sender, string message);
 
    public class QueueSSS
    {
        public event StringHandler OnMessage;
 
        private ListSSS list = new ListSSS();
        private System.Threading.Thread tdQueuer;
 
        public bool isSending = true;
        public QueueSSS()
        {
            list.OnAdd += Message;
            list.OnSend += Message;
        }
 
        public void Start()
        {
            tdQueuer = new System.Threading.Thread(Send);
            tdQueuer.IsBackground = true;
            tdQueuer.Start();
        }
 
        private void Send()
        {
            try
            {
                Message(this, "Начато отправление запросов");
                while (isSending)
                {
                    System.Threading.Thread.Sleep(100);
                    list.sendNext();
                }
            }
            catch (System.Threading.ThreadAbortException)
            {
                Message(this, "Прекращение отправки запросов");
            }
        }
 
        public void Stop()
        { tdQueuer.Abort(); }
 
        public void AddQueuer(int number)
        { list.add(number); }
 
        public void Message(object sender, string message)
        {
            if (OnMessage != null)
                OnMessage(sender, message);
        }
    }
 
    public class ListSSS
    {
        public event StringHandler OnSend;
        public event StringHandler OnAdd;
 
        private List<int> numbers = new List<int>();
        public int lastSended = 0;
 
        public void add(int number)
        {
            numbers.Add(number);
            if (OnAdd != null) OnAdd(this, "Добавлен запрос #" + number);
        }
 
        public void sendNext()
        {
            lock (numbers)
            {
                if (numbers.Count > 0)
                {
                    new System.Threading.Thread(send).Start();
                }
            }
        }
 
        private void send()
        {
            lock (numbers)
            {
                lastSended = numbers[0];
                if (OnSend != null) OnSend(this, "Отправка #" + lastSended);
 
                System.Threading.Thread.Sleep(2000);
 
                numbers.RemoveAt(0);
                if (OnSend != null)  OnSend(this, "Получение  #" + lastSended);
            }
        }
    }
}

using System;
using System.Collections.Generic;
 
namespace ConsoleTest
{
    public class Program
    {
        private static void QueueSSS_OnMessage(object sender, string message)
        {
            Console.WriteLine(sender.ToString() + ": " + message);
        }
 
        public static void Main()
        {
            QueueSSS que = new QueueSSS();
            que.OnMessage += QueueSSS_OnMessage;
 
            int i;
            for (i = 0; i < 3; i++)
                que.AddQueuer(i);
 
           
            que.Start();
            Console.ReadLine();
 
            string end = "";
            while (end != "end")
            {
                end = Console.ReadLine();
                if (end!="end")
                    que.AddQueuer(i++);
            }
 
            que.Stop();
            Console.ReadLine();
        }
    }
 
    public delegate void StringHandler(object sender, string message);
 
    public class QueueSSS
    {
        public event StringHandler OnMessage;
 
        private ListSSS list = new ListSSS();
        private System.Threading.Thread tdQueuer;
 
        public bool isSending = true;
        public QueueSSS()
        {
            list.OnAdd += Message;
            list.OnSend += Message;
        }
 
        public void Start()
        {
            tdQueuer = new System.Threading.Thread(Send);
            tdQueuer.IsBackground = true;
            tdQueuer.Start();
        }
 
        private void Send()
        {
            try
            {
                Message(this, "Начато отправление запросов");
                while (isSending)
                {
                    System.Threading.Thread.Sleep(100);
                    list.sendNext();
                }
            }
            catch (System.Threading.ThreadAbortException)
            {
                Message(this, "Прекращение отправки запросов");
            }
        }
 
        public void Stop()
        { tdQueuer.Abort(); }
 
        public void AddQueuer(int number)
        { list.add(number); }
 
        public void Message(object sender, string message)
        {
            if (OnMessage != null)
                OnMessage(sender, message);
        }
    }
 
    public class ListSSS
    {
        public event StringHandler OnSend;
        public event StringHandler OnAdd;
 
        private List<int> numbers = new List<int>();
        public int lastSended = 0;
 
        public void add(int number)
        {
            numbers.Add(number);
            if (OnAdd != null) OnAdd(this, "Добавлен запрос #" + number);
        }
 
        public void sendNext()
        {
            lock (numbers)
            {
                if (numbers.Count > 0)
                {
                    new System.Threading.Thread(send).Start();
                }
            }
        }
 
        private void send()
        {
            lock (numbers)
            {
                lastSended = numbers[0];
                if (OnSend != null) OnSend(this, "Отправка #" + lastSended);
 
                System.Threading.Thread.Sleep(2000);
 
                numbers.RemoveAt(0);
                if (OnSend != null)  OnSend(this, "Получение  #" + lastSended);
            }
        }
    }
}

namespace WinFormTest
{
    public partial class AllTest : Form
    {
        int i = 0;
        QueueSSS que;
        public AllTest()
        {
            InitializeComponent();
            que = new QueueSSS();
            que.OnMessage += QueueSSS_OnMessage;
 
            que.Start();
        }
 
        public void QueueSSS_OnMessage(object sender, string message)
        {
            if (this.InvokeRequired)
                this.BeginInvoke(new MethodInvoker(() => listBox1.Items.Add(sender.ToString() + ": " + message)));
            else
                listBox1.Items.Add(sender.ToString() + ": " + message);
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            que.AddQueuer(i++);
        }
    }
 
    public delegate void StringHandler(object sender, string message);
 
    public class QueueSSS
    {
        public event StringHandler OnMessage;
 
        private ListSSS list = new ListSSS();
        private System.Threading.Thread tdQueuer;
 
        public bool isSending = true;
        public QueueSSS()
        {
            list.OnAdd += Message;
            list.OnSend += Message;
        }
 
        public void Start()
        {
            tdQueuer = new System.Threading.Thread(Send);
            tdQueuer.IsBackground = true;
            tdQueuer.Start();
        }
 
        private void Send()
        {
            try
            {
                Message(this, "Начато отправление запросов");
                while (isSending)
                {
                    System.Threading.Thread.Sleep(100);
                    list.sendNext();
                }
            }
            catch (System.Threading.ThreadAbortException)
            {
                Message(this, "Прекращение отправки запросов");
            }
        }
 
        public void Stop()
        { tdQueuer.Abort(); }
 
        public void AddQueuer(int number)
        { list.add(number); }
 
        public void Message(object sender, string message)
        {
            if (OnMessage != null)
                OnMessage(sender, message);
        }
    }
 
    public class ListSSS
    {
        public event StringHandler OnSend;
        public event StringHandler OnAdd;
 
        private List<int> numbers = new List<int>();
        public int lastSended = 0;
 
        public void add(int number)
        {
            numbers.Add(number);
            if (OnAdd != null) OnAdd(this, "Добавлен запрос #" + number);
        }
 
        public void sendNext()
        {
            lock (numbers)
            {
                if (numbers.Count > 0)
                {
                    new System.Threading.Thread(send).Start();
                }
            }
        }
 
        private void send()
        {
            lock (numbers)
            {
                lastSended = numbers[0];
                if (OnSend != null) OnSend(this, "Отправка #" + lastSended);
 
                System.Threading.Thread.Sleep(2000);
 
                numbers.RemoveAt(0);
                if (OnSend != null) OnSend(this, "Получение  #" + lastSended);
            }
        }
    }
}

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.IO;
using System.Threading;
 
namespace WinFormTest
{
    //класс-форма
    public partial class AllTest : Form
    {
        //текущий номер запроса
        int i = 0;
        // экземпляр класса-очереди запросов
        QueueSSS que;
 
        //конструктор формы
        public AllTest()
        {
            InitializeComponent();
 
            //создание экземпляра очереди
            que = new QueueSSS();
            //добавление обработчика на событие
            que.OnMessage += QueueSSS_OnMessage;
 
            //запуск автоотправления запросов
            que.Start();
        }
 
        //метод - обработчик события сообщения от очереди
        public void QueueSSS_OnMessage(object sender, string message)
        {
            //если нужно возвращение к базовому потоку
            if (this.InvokeRequired)
                //вывод сообщения в базовом потоке
                this.BeginInvoke(new MethodInvoker(() => listBox1.Items.Add(sender.ToString() + ": " + message)));
            else
                //вывод сообщения в текущем потоке потоке
                listBox1.Items.Add(sender.ToString() + ": " + message);
        }
 
        //метод - обработчик нажатия на кнопку
        private void button1_Click(object sender, EventArgs e)
        {
            //добавление ещё одного запроса
            que.AddQueuer(i++);
        }
    }//конец формы
 
    //делегат для работы с событиями-сообщениями
    public delegate void StringHandler(object sender, string message);
 
    //класс - очередь запросов
    public class QueueSSS
    {
        //событие на вывод сообщения
        public event StringHandler OnMessage;
 
        //экземпляр класса - списка неотправленных запросов
        private ListSSS list = new ListSSS();
        //поток для постоянной отправки запросов
        private System.Threading.Thread tdQueuer;
 
        //флаг работы потока
        public bool isSending = true;
 
        //конструктор класса
        public QueueSSS()
        {
            //добавление обработчиков событиям списка
            list.OnAdd += Message;
            list.OnSend += Message;
        }
 
        //запуск потока отправки запросов
        public void Start()
        {
            tdQueuer = new System.Threading.Thread(Send);
            tdQueuer.IsBackground = true;
            tdQueuer.Start();
        }
 
        //потоковый метод отправки запросов
        private void Send()
        {
            try
            {
                //вызов метода сообщения
                Message(this, "Начато отправление запросов");
                
                //пока установлен флаг...
                while (isSending)
                {
                    //небольшая остановка потока
                    System.Threading.Thread.Sleep(100);
                    //вызов метода отправки сообщения в списке неотправленных запросов
                    list.sendNext();
                }
            }
            //при прерывании работы потока
            catch (System.Threading.ThreadAbortException)
            {
                //вызов метода сообщения
                Message(this, "Прекращение отправки запросов");
            }
        }
 
        //метод остановки посылки
        public void Stop()
        { tdQueuer.Abort(); }
 
        //метод добавления запроса
        public void AddQueuer(int number)
        { list.add(number); }
 
        //метод выдачи сообщения
        public void Message(object sender, string message)
        {
            //если у события есть обработчик..
            if (OnMessage != null)
                //вызов события с переданными параметрами
                OnMessage(sender, message);
        }
    }//конец очереди
 
    //класс - список неотправленных запросов
    public class ListSSS
    {
        //событие на отправку
        public event StringHandler OnSend;
        //событие на добавление
        public event StringHandler OnAdd;
 
        //список неотправленных запросов
        private List<int> numbers = new List<int>();
        //номер последнего отправленного запроса
        public int lastSended = 0;
 
        //метод добавления запроса
        public void add(int number)
        {
            //добавление в список запроса
            numbers.Add(number);
            //вызов метода сообщения
            if (OnAdd != null) OnAdd(this, "Добавлен запрос #" + number);
        }
 
        //метод отправки сообщения (именно он постоянно вызывается в классе-обладателе)
        public void sendNext()
        {
            //синхронизация
            lock (numbers)
            {
                //если список не пустой
                if (numbers.Count > 0)
                {
                    //запуск нового потока отправки
                    new System.Threading.Thread(send).Start();
                }
            }
        }
 
        //метод отправки, вызываемый в новом потоке
        private void send()
        {
            //синхронизация
            lock (numbers)
            {
                //установка нового последнего отправленного
                lastSended = numbers[0];
                //сообщение об отправке
                if (OnSend != null) OnSend(this, "Отправка #" + lastSended);
 
                //ожидание (видимо тут должна быть обработка чего-либо, хотя я сделал-бы в другом методе)
                System.Threading.Thread.Sleep(2000);
 
                //удаление последнего отправленного
                numbers.RemoveAt(0);
                //отправка о якобы получении ответа
                if (OnSend != null) OnSend(this, "Получение  #" + lastSended);
            }
        }
    }//конец списка неотправленных
}