Skip to content
The Chat Archive
gpt-4.1-mini-2025-04-14· OpenAI WildChat-4.8M (AI2)

1. Разработать C# Windows Forms приложение, которое будет использовать объект-семафор…

  1. User
    1. Разработать C# Windows Forms приложение, которое будет использовать объект-семафор следующим образом. По нажатию на кнопку "Создать поток" создается новый поток и помещается в первый список, где нахо- дятся все созданные потоки. Порядковый номер пото- ка берется от 1 и увеличивается на один. При двойном клике на потоке, поток перемещается в список ожидаю- щих потоков, где он будет находиться до тех пор, пока в семафоре не освободится для него место. Как только такое место освободилось, поток перемещается из спи- ска ожидания в список рабочих потоков и приступает к работе. Работа заключается в том, чтобы увеличивать ло- кальный счетчик каждого потока на единицу в секун- ду и отображать это значение. При двойном клике по потоку в списке рабочих потоков – поток прекращает свою работу, удаляется из списка и освобождает ме- сто для очередного ожидающего потока. Количество свободных мест задается в счетчике. При изменении счетчика более "старые" потоки покидают список, если произошло уменьшение счетчика, или же добавляются новые "ожидающие" потоки при увеличении значения счетчика. Изменение размера формы происходит, ди- намически подстраиваясь под наибольшее количество потоков в каком-либо списке. Верни полный код для всех файлов проекта.
  2. Assistant
    // Проект: SemaphoreThreadsApp
    // Файлы: Program.cs, MainForm.cs, MainForm.Designer.cs
    
    // -------------------- Program.cs --------------------
    using System;
    using System.Windows.Forms;
    
    namespace SemaphoreThreadsApp
    {
        static class Program
        {
            /// <summary>
            /// Точка входа в приложение.
            /// </summary>
            [STAThread]
            static void Main()
            {
                Application.EnableVisualStyles();
                Application.SetCompatibleTextRenderingDefault(false);
                Application.Run(new MainForm());
            }
        }
    }
    
    // -------------------- MainForm.Designer.cs --------------------
    namespace SemaphoreThreadsApp
    {
        partial class MainForm
        {
            /// <summary>
            /// Обязательная переменная конструктора.
            /// </summary>
            private System.ComponentModel.IContainer components = null;
    
            /// <summary>
            /// Освободить все используемые ресурсы.
            /// </summary>
            /// <param name="disposing">истинно, если управляемый ресурс должен быть удален; иначе ложно.</param>
            protected override void Dispose(bool disposing)
            {
                if (disposing)
                {
                    // Остановить все потоки при закрытии
                    foreach(var t in threadsAll.Values)
                    {
                        t.RequestStop();
                    }
    
                    components?.Dispose();
                }
                base.Dispose(disposing);
            }
    
            #region Код, автоматически созданный конструктором форм Windows
    
            /// <summary>
            /// Требуемый метод для поддержки конструктора — не изменяйте
            /// содержимое этого метода с помощью редактора кода.
            /// </summary>
            private void InitializeComponent()
            {
                this.btnCreateThread = new System.Windows.Forms.Button();
                this.numCapacity = new System.Windows.Forms.NumericUpDown();
                this.lblCapacity = new System.Windows.Forms.Label();
                this.lstAllThreads = new System.Windows.Forms.ListBox();
                this.lstWaitingThreads = new System.Windows.Forms.ListBox();
                this.lstWorkingThreads = new System.Windows.Forms.ListBox();
                this.lblAllThreads = new System.Windows.Forms.Label();
                this.lblWaiting = new System.Windows.Forms.Label();
                this.lblWorking = new System.Windows.Forms.Label();
                ((System.ComponentModel.ISupportInitialize)(this.numCapacity)).BeginInit();
                this.SuspendLayout();
                // 
                // btnCreateThread
                // 
                this.btnCreateThread.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
                this.btnCreateThread.Location = new System.Drawing.Point(675, 12);
                this.btnCreateThread.Name = "btnCreateThread";
                this.btnCreateThread.Size = new System.Drawing.Size(120, 30);
                this.btnCreateThread.TabIndex = 0;
                this.btnCreateThread.Text = "Создать поток";
                this.btnCreateThread.UseVisualStyleBackColor = true;
                this.btnCreateThread.Click += new System.EventHandler(this.btnCreateThread_Click);
                // 
                // numCapacity
                // 
                this.numCapacity.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
                this.numCapacity.Location = new System.Drawing.Point(675, 70);
                this.numCapacity.Minimum = new decimal(new int[] {
                0,
                0,
                0,
                0});
                this.numCapacity.Maximum = new decimal(new int[] {
                100,
                0,
                0,
                0});
                this.numCapacity.Name = "numCapacity";
                this.numCapacity.Size = new System.Drawing.Size(120, 22);
                this.numCapacity.TabIndex = 1;
                this.numCapacity.Value = new decimal(new int[] {
                3,
                0,
                0,
                0});
                this.numCapacity.ValueChanged += new System.EventHandler(this.numCapacity_ValueChanged);
                // 
                // lblCapacity
                // 
                this.lblCapacity.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
                this.lblCapacity.AutoSize = true;
                this.lblCapacity.Location = new System.Drawing.Point(672, 50);
                this.lblCapacity.Name = "lblCapacity";
                this.lblCapacity.Size = new System.Drawing.Size(129, 17);
                this.lblCapacity.TabIndex = 2;
                this.lblCapacity.Text = "Количество мест:";
                // 
                // lstAllThreads
                // 
                this.lstAllThreads.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
                | System.Windows.Forms.AnchorStyles.Left)));
                this.lstAllThreads.FormattingEnabled = true;
                this.lstAllThreads.ItemHeight = 16;
                this.lstAllThreads.Location = new System.Drawing.Point(12, 32);
                this.lstAllThreads.Name = "lstAllThreads";
                this.lstAllThreads.SelectionMode = System.Windows.Forms.SelectionMode.None;
                this.lstAllThreads.Size = new System.Drawing.Size(170, 308);
                this.lstAllThreads.TabIndex = 3;
                this.lstAllThreads.DoubleClick += new System.EventHandler(this.lstAllThreads_DoubleClick);
                // 
                // lstWaitingThreads
                // 
                this.lstWaitingThreads.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)));
                this.lstWaitingThreads.FormattingEnabled = true;
                this.lstWaitingThreads.ItemHeight = 16;
                this.lstWaitingThreads.Location = new System.Drawing.Point(232, 32);
                this.lstWaitingThreads.Name = "lstWaitingThreads";
                this.lstWaitingThreads.SelectionMode = System.Windows.Forms.SelectionMode.None;
                this.lstWaitingThreads.Size = new System.Drawing.Size(170, 308);
                this.lstWaitingThreads.TabIndex = 4;
                // 
                // lstWorkingThreads
                // 
                this.lstWorkingThreads.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) | System.Windows.Forms.AnchorStyles.Right));
                this.lstWorkingThreads.FormattingEnabled = true;
                this.lstWorkingThreads.ItemHeight = 16;
                this.lstWorkingThreads.Location = new System.Drawing.Point(456, 32);
                this.lstWorkingThreads.Name = "lstWorkingThreads";
                this.lstWorkingThreads.SelectionMode = System.Windows.Forms.SelectionMode.None;
                this.lstWorkingThreads.Size = new System.Drawing.Size(170, 308);
                this.lstWorkingThreads.TabIndex = 5;
                this.lstWorkingThreads.DoubleClick += new System.EventHandler(this.lstWorkingThreads_DoubleClick);
                // 
                // lblAllThreads
                // 
                this.lblAllThreads.AutoSize = true;
                this.lblAllThreads.Location = new System.Drawing.Point(12, 12);
                this.lblAllThreads.Name = "lblAllThreads";
                this.lblAllThreads.Size = new System.Drawing.Size(136, 17);
                this.lblAllThreads.TabIndex = 6;
                this.lblAllThreads.Text = "Все созданные потоки";
                // 
                // lblWaiting
                // 
                this.lblWaiting.Anchor = System.Windows.Forms.AnchorStyles.Top;
                this.lblWaiting.AutoSize = true;
                this.lblWaiting.Location = new System.Drawing.Point(229, 12);
                this.lblWaiting.Name = "lblWaiting";
                this.lblWaiting.Size = new System.Drawing.Size(124, 17);
                this.lblWaiting.TabIndex = 7;
                this.lblWaiting.Text = "Ожидающие потоки";
                // 
                // lblWorking
                // 
                this.lblWorking.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
                this.lblWorking.AutoSize = true;
                this.lblWorking.Location = new System.Drawing.Point(453, 12);
                this.lblWorking.Name = "lblWorking";
                this.lblWorking.Size = new System.Drawing.Size(102, 17);
                this.lblWorking.TabIndex = 8;
                this.lblWorking.Text = "Рабочие потоки";
                // 
                // MainForm
                // 
                this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 16F);
                this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
                this.ClientSize = new System.Drawing.Size(807, 353);
                this.Controls.Add(this.lblWorking);
                this.Controls.Add(this.lblWaiting);
                this.Controls.Add(this.lblAllThreads);
                this.Controls.Add(this.lstWorkingThreads);
                this.Controls.Add(this.lstWaitingThreads);
                this.Controls.Add(this.lstAllThreads);
                this.Controls.Add(this.lblCapacity);
                this.Controls.Add(this.numCapacity);
                this.Controls.Add(this.btnCreateThread);
                this.MinimumSize = new System.Drawing.Size(520, 300);
                this.Name = "MainForm";
                this.Text = "Semaphore Threads App";
                ((System.ComponentModel.ISupportInitialize)(this.numCapacity)).EndInit();
                this.ResumeLayout(false);
                this.PerformLayout();
    
            }
    
            #endregion
    
            private System.Windows.Forms.Button btnCreateThread;
            private System.Windows.Forms.NumericUpDown numCapacity;
            private System.Windows.Forms.Label lblCapacity;
            private System.Windows.Forms.ListBox lstAllThreads;
            private System.Windows.Forms.ListBox lstWaitingThreads;
            private System.Windows.Forms.ListBox lstWorkingThreads;
            private System.Windows.Forms.Label lblAllThreads;
            private System.Windows.Forms.Label lblWaiting;
            private System.Windows.Forms.Label lblWorking;
        }
    }
    
    // -------------------- MainForm.cs --------------------
    using System;
    using System.Collections.Generic;
    using System.Threading;
    using System.Windows.Forms;
    
    namespace SemaphoreThreadsApp
    {
        public partial class MainForm : Form
        {
            // Нумерация потоков от 1
            private int nextThreadNumber = 1;
    
            // Все потоки (созданные)
            // Ключ - номер потока, значение - объект ManagedThread
            private Dictionary<int, ManagedThread> threadsAll = new Dictionary<int, ManagedThread>();
    
            // Список ожидающих потоков (номера)
            private List<int> waitingThreads = new List<int>();
    
            // Список работающих потоков (номера)
            private List<int> workingThreads = new List<int>();
    
            // Семафор для ограничения одновременных рабочих потоков
            private SemaphoreSlim semaphore;
    
            // Объект блокировки синхронизации коллекций
            private readonly object locker = new object();
    
            public MainForm()
            {
                InitializeComponent();
    
                // Инициализация семафора исходя из начального значения
                semaphore = new SemaphoreSlim((int)numCapacity.Value, 100);
    
                UpdateUILists();
    
                AdjustFormHeight();
            }
    
            private void btnCreateThread_Click(object sender, EventArgs e)
            {
                int threadNumber;
                lock (locker)
                {
                    threadNumber = nextThreadNumber++;
                }
    
                var mt = new ManagedThread(threadNumber, this);
    
                lock (locker)
                {
                    threadsAll[threadNumber] = mt;
                    waitingThreads.Add(threadNumber);
                }
    
                UpdateUILists();
    
                TryStartWaitingThreads();
    
                AdjustFormHeight();
            }
    
            // При двойном клике на списке всех потоков - переместить поток в ожидание (если это нужно)
            private void lstAllThreads_DoubleClick(object sender, EventArgs e)
            {
                int index = lstAllThreads.SelectedIndex;
                if (index < 0) return;
    
                int threadId;
    
                lock (locker)
                {
                    if (index >= lstAllThreads.Items.Count)
                        return;
    
                    object item = lstAllThreads.Items[index];
                    if (item is ThreadListItem tli)
                    {
                        threadId = tli.ThreadNumber;
    
                        if (waitingThreads.Contains(threadId) || workingThreads.Contains(threadId))
                        {
                            // Уже в списках ожидания или работы - игнорируем
                            return;
                        }
    
                        // Если в списке всех, значит он "создан но не в ожидании", 
                        // по условию нужно переместить в waiting
    
                        // Добавим в waiting
                        waitingThreads.Add(threadId);
                    }
                    else
                    {
                        return;
                    }
                }
    
                // Запустить потоки, если семафор позволяет
                TryStartWaitingThreads();
    
                UpdateUILists();
                AdjustFormHeight();
            }
    
            // При двойном клике в списке рабочих потоков - остановить поток
            private void lstWorkingThreads_DoubleClick(object sender, EventArgs e)
            {
                int index = lstWorkingThreads.SelectedIndex;
                if (index < 0) return;
    
                int threadId;
                lock (locker)
                {
                    if (index >= lstWorkingThreads.Items.Count)
                        return;
    
                    object item = lstWorkingThreads.Items[index];
                    if (item is ThreadListItem tli)
                    {
                        threadId = tli.ThreadNumber;
                        if (!workingThreads.Contains(threadId))
                        {
                            return;
                        }
                    }
                    else
                    {
                        return;
                    }
                }
    
                StopWorkingThread(threadId);
    
                UpdateUILists();
                AdjustFormHeight();
            }
    
            // Попытка запустить ожидающие потоки, если есть свободные места в семафоре
            private void TryStartWaitingThreads()
            {
                List<int> toStart = new List<int>();
    
                lock (locker)
                {
                    while (waitingThreads.Count > 0 && semaphore.CurrentCount > 0)
                    {
                        int threadId = waitingThreads[0];
                        waitingThreads.RemoveAt(0);
    
                        toStart.Add(threadId);
                        workingThreads.Add(threadId);
    
                        // Занять место в семафоре
                        semaphore.Wait();
                    }
                }
    
                foreach (var id in toStart)
                {
                    ManagedThread mt;
                    lock (locker)
                    {
                        if (threadsAll.TryGetValue(id, out mt))
                        {
                            mt.StartWork();
                        }
                    }
                }
    
                UpdateUILists();
                AdjustFormHeight();
            }
    
            // Остановить рабочий поток
            private void StopWorkingThread(int threadId)
            {
                ManagedThread mt;
    
                lock (locker)
                {
                    if (!workingThreads.Remove(threadId))
                        return;
    
                    if (!threadsAll.TryGetValue(threadId, out mt))
                        return;
                }
    
                // Остановить поток и удалить из all + рабочие уже удалены выше
                mt.RequestStop();
                lock (locker)
                {
                    threadsAll.Remove(threadId);
                }
    
                // Освободить место в семафоре
                semaphore.Release();
    
                // Попытка запустить ожидатели, т.к. место освободилось
                TryStartWaitingThreads();
    
                UpdateUILists();
                AdjustFormHeight();
            }
    
            // Изменение количества мест
            private void numCapacity_ValueChanged(object sender, EventArgs e)
            {
                int newCapacity = (int)numCapacity.Value;
    
                if (newCapacity < 0)
                    newCapacity = 0;
    
                lock (locker)
                {
                    // Изменяем доступное количество мест семафора
                    int currentCount = semaphore.CurrentCount;
    
                    // Поскольку SemaphoreSlim не умеет динамически изменять максимальное число,
                    // создадим новый семафор:
    
                    var newSemaphore = new SemaphoreSlim(newCapacity, 100);
    
                    // Пока добавим в новый семафор столько, чтобы рабочие потоки имели место
    
                    int runningCount = workingThreads.Count;
    
                    // Чтобы избежать блокирования, старый SemaphoreSlim освобождаем полностью, т.к. он больше не нужен
                    semaphore.Dispose();
                    semaphore = newSemaphore;
    
                    // Пропускаем до runningCount "занятых" мест
                    for (int i = 0; i < runningCount && i < newCapacity; i++)
                    {
                        semaphore.Wait();
                    }
    
                    // Обработка уменьшения счетчика - нужно удалить "старые" потоки из all,
                    // если потоков стало больше, чем capacity
    
                    if (runningCount > newCapacity)
                    {
                        // Кол-во потоков, которое нужно удалить с конца списка созданных потоков.
                        // Удалим самых "старых" рабочих потоков - т.е. с конца workingThreads
    
                        int needRemove = runningCount - newCapacity;
    
                        // Берём последние needRemove потоков из workingThreads
                        var toRemove = new List<int>();
    
                        for (int i = workingThreads.Count - 1; i >= 0 && needRemove > 0; i--, needRemove--)
                        {
                            toRemove.Add(workingThreads[i]);
                        }
    
                        foreach (var rm in toRemove)
                        {
                            StopWorkingThread(rm);
                        }
                    }
    
                    // Если увеличился capacity - можем попытаться стартовать ожидающие потоки
                    if (newCapacity > runningCount)
                    {
                        TryStartWaitingThreads();
                    }
                }
    
                UpdateUILists();
                AdjustFormHeight();
            }
    
            // Обновление списков отображения
            private void UpdateUILists()
            {
                if (InvokeRequired)
                {
                    Invoke(new Action(UpdateUILists));
                    return;
                }
    
                lock (locker)
                {
                    lstAllThreads.Items.Clear();
                    lstWaitingThreads.Items.Clear();
                    lstWorkingThreads.Items.Clear();
    
                    // Все созданные потоки (показываем все, вне зависимости от состояния)
                    foreach (var pair in threadsAll)
                    {
                        int num = pair.Key;
                        var mt = pair.Value;
                        lstAllThreads.Items.Add(new ThreadListItem(num, mt.CurrentCount));
                    }
    
                    foreach (var num in waitingThreads)
                    {
                        if (threadsAll.TryGetValue(num, out var mt))
                            lstWaitingThreads.Items.Add(new ThreadListItem(num, mt.CurrentCount));
                    }
    
                    foreach (var num in workingThreads)
                    {
                        if (threadsAll.TryGetValue(num, out var mt))
                            lstWorkingThreads.Items.Add(new ThreadListItem(num, mt.CurrentCount));
                    }
                }
            }
    
            // Встроенный класс для отображения в списках
            private class ThreadListItem
            {
                public int ThreadNumber { get; }
                public int CurrentCount { get; }
    
                public ThreadListItem(int num, int count)
                {
                    ThreadNumber = num;
                    CurrentCount = count;
                }
    
                public override string ToString()
                {
                    return $"Поток {ThreadNumber} | Счётчик = {CurrentCount}";
                }
            }
    
            // Регулировка формы под максимальную длину списка
            private void AdjustFormHeight()
            {
                if (InvokeRequired)
                {
                    Invoke(new Action(AdjustFormHeight));
                    return;
                }
    
                int allCount, waitCount, workCount;
    
                lock (locker)
                {
                    allCount = threadsAll.Count;
                    waitCount = waitingThreads.Count;
                    workCount = workingThreads.Count;
                }
    
                int maxCount = Math.Max(allCount, Math.Max(waitCount, workCount));
    
                // Высота одного элемента в списке = 16 + padding (~4),
                // но для надежности возьмём 20 пикселей на элемент
    
                int desiredListHeight = maxCount * 20 + 40; // +запас под надписи
    
                // Минимальная высота формы 300 (указана в дизайнере)
    
                int newHeight = Math.Max(300, desiredListHeight + 80); // +80 для кнопок и полей
    
                if (Height != newHeight)
                    Height = newHeight;
            }
    
            // Класс для управления потоком, его состоянием и счетчиком
            private class ManagedThread
            {
                private Thread thread;
                private volatile bool shouldStop = false;
                private int localCounter;
                private readonly int threadNumber;
                private readonly MainForm form;
    
                private ManualResetEventSlim pauseEvent = new ManualResetEventSlim(true);
    
                public int CurrentCount => Volatile.Read(ref localCounter);
    
                public ManagedThread(int threadNumber, MainForm form)
                {
                    this.threadNumber = threadNumber;
                    this.form = form;
                    localCounter = 0;
    
                    thread = new Thread(ThreadProc)
                    {
                        IsBackground = true,
                        Name = $"ManagedThread_{threadNumber}"
                    };
                    thread.Start();
                    // Сразу поток ждет сигнала на работу
                    pauseEvent.Reset();
                }
    
                // Запуск работы потока
                public void StartWork()
                {
                    pauseEvent.Set();
                }
    
                // Основной метод потока
                private void ThreadProc()
                {
                    while (!shouldStop)
                    {
                        pauseEvent.Wait();
    
                        if (shouldStop)
                            break;
    
                        Interlocked.Increment(ref localCounter);
    
                        form.SafeUpdateUIForThread(threadNumber, localCounter);
    
                        // Ждем 1 секунду
                        for (int i = 0; i < 10 && !shouldStop; i++)
                        {
                            Thread.Sleep(100);
                        }
                    }
                }
    
                // Метод запроса остановки потока
                public void RequestStop()
                {
                    shouldStop = true;
                    pauseEvent.Set();
                    thread.Join(2000);
                }
            }
    
            // Метод безопасного обновления UI по счетчику.
            private delegate void UpdateThreadCounterDelegate(int threadNum, int counter);
    
            private Dictionary<int, int> threadCounters = new Dictionary<int, int>();
    
            private void SafeUpdateUIForThread(int threadNum, int counter)
            {
                if (InvokeRequired)
                {
                    Invoke(new UpdateThreadCounterDelegate(SafeUpdateUIForThread), threadNum, counter);
                    return;
                }
    
                // Обновить внутреннее состояние счетчика
                lock (locker)
                    threadCounters[threadNum] = counter;
    
                // Обновить элементы списка
                UpdateUILists();
            }
        }
    }
    

    Подсказки по использованию и структуре кода:

    • Кнопка Создать поток создает поток, который сразу попадает в список созданных и в список ожидания.
    • При двойном клике на потоке в списке Все созданные потоки поток отправляется в очередь ожидания (если там ещё нет). Поток начнёт работать, только когда семафор позволит.
    • Потоки, работающие, находятся в списке Рабочие потоки. Двойной клик по ним останавливает поток, удаляет его из списков и освобождает место в семафоре.
    • Параметр семафора (число одновременных рабочих потоков) можно изменить с помощью NumericUpDown. При его уменьшении "старые" потоки удаляются, а при увеличении - запускаются новые ожидающие.
    • Форма динамически изменяет высоту, подстраиваясь под максимальное количество элементов в любом списке.
    • Состояние счетчика каждого потока обновляется каждую секунду.
    • Для каждого потока создаётся отдельный Thread, который не работает сразу, а ждет сигнала (ManualResetEventSlim).
    • В списках отображается номер потока и текущий счетчик.

    Как собрать проект:

    1. Создать Windows Forms проект в Visual Studio (.NET Framework или .NET 6+).
    2. Заменить Program.cs, MainForm.cs, MainForm.Designer.cs содержимым из ответа.
    3. Собрать и запустить приложение.

    Если нужны дополнительные комментарии или разъяснения по коду — пишите.