Справочная информацияРаботники никогда не перестают быть занятыми

Ваш цикл вызывает тупик, BGW не может завершиться. Проблема в событии RunWorkerCompleted, оно возникает в потоке пользовательского интерфейса. Этот бит магии BGW требует, чтобы поток пользовательского интерфейса был в режиме ожидания, он должен перекачивать свой цикл сообщений. Проблема в том, что поток пользовательского интерфейса не простаивает и не перекачивает сообщения, он застрял в цикле for. Таким образом, обработчик событий не может работать, и IsBusy остается верным.

Вам нужно будет сделать это по-другому. Воспользуйтесь событием RunWorkerCompleted для запуска кода, который вы обычно запускаете после этого цикла for. Не поддавайтесь искушению вызвать Application.DoEvents () внутри цикла.

Я предлагаю вам изменить свой код для обработки события RunWorkerCompleted, чтобы получать уведомления, когда ваши BackgroundWorkers завершат свою работу. Пример использования BackgroundWorker приведен в официальной документации. .

У меня была такая же проблема при использовании фоновых рабочих, и я пришел к выводу, что если вы используете sleep () внутри цикла, он застрянет. Вы можете использовать событие RunWorkerCompleted и установить логический флаг, чтобы указать, когда каждый рабочий процесс завершен.

Или, если вы хотите прервать поток, независимо от того, можете ли вы использовать потоки вместо фоновых рабочих. Однако тогда вы теряете простоту использования в отношении событий, которые предоставляет фоновый рабочий.

Ваш основной поток должен перекачивать сообщения Windows (либо вызывая Application.DoEvents в вашем цикле while, либо, что еще лучше, используя Systems.Windows.Forms.Timer вместо цикла).

Если вы не перекачиваете сообщения Windows, «завершенные» уведомления фонового рабочего не будут обрабатываться, поэтому статус останется занятым.

У меня была аналогичная проблема, и я решил ее решить, заключив основную функцию в оператор try... catch... and finally....

.IsBusy указывает только на то, что фоновый рабочий действительно выполняет операцию. Он будет занят, пока "что-то" не доделано. Кажется, что «что-то» не заканчивается, и ваши второстепенные сотрудники заняты.

Так что было бы полезно, если бы вы могли объяснить, что такое «что-то» и, возможно, сколько времени требуется для выполнения «чего-то» в основном потоке.

Проблема в том, что все, что вы делаете в worker.RunWorkerAsync(), никогда не будет завершено. Может быть, в вашем DoWork событии есть бесконечный цикл или что-то подобное.

Вот рабочий пример, который выбирает следующего бесплатного работника:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        private static List<MyWorker> _Workers;

        static void Main(string[] args)
        {
            _Workers = new List<MyWorker>();

            for (int i = 0; i < 5; i++)
            {
                _Workers.Add(CreateDefaultWorker(i));
            }

            StartJobs(20000);
            Console.ReadKey();
        }

        private static void StartJobs(int runtime)
        {
            Random rand = new Random();
            DateTime startTime = DateTime.Now;

            while (DateTime.Now - startTime < TimeSpan.FromMilliseconds(runtime))
            {
                var freeWorker = GetFreeWorker();

                if (freeWorker != null)
                {
                    freeWorker.Worker.RunWorkerAsync(new Action(() => DoSomething(freeWorker.Index, rand.Next(500, 2000))));
                }
                else
                {
                    Console.WriteLine("No free worker available!");
                    Console.WriteLine("Waiting for free one...");
                    WaitForFreeOne();
                }
            }
        }

        private static MyWorker GetFreeWorker()
        {
            foreach (var worker in _Workers)
            {
                if (!worker.Worker.IsBusy)
                    return worker;
            }

            return null;
        }

        private static void WaitForFreeOne()
        {
            while (true)
            {
                foreach (var worker in _Workers)
                {
                    if (!worker.Worker.IsBusy)
                        return;
                }
                Thread.Sleep(1);
            }
        }

        private static MyWorker CreateDefaultWorker(int index)
        {
            var worker = new MyWorker(index);

            worker.Worker.DoWork += (sender, e) => ((Action)e.Argument).Invoke();
            worker.Worker.RunWorkerCompleted += (sender, e) => Console.WriteLine("Job finished in worker " + worker.Index);

            return worker;
        }

        static void DoSomething(int index, int timeout)
        {
            Console.WriteLine("Worker {1} starts to work for {0} ms", timeout, index);
            Thread.Sleep(timeout);
        }
    }

    public class MyWorker
    {
        public int Index { get; private set; }
        public BackgroundWorker Worker { get; private set; }

        public MyWorker(int index)
        {
            Index = index;
            Worker = new BackgroundWorker();
        }
    }
}

Рабочее решение вашей проблемы показано в примере ниже. Как объяснил Ханс Пассант, ваш код работает в фоновом режиме, но RunWorkerCompleted каждого потока оценивается только в потоке пользовательского интерфейса. Для этого вы можете поставить свой запрос в очередь потоков UIs, ThreadPool. Таким образом пользовательский интерфейс оценивает событие RunWorkerCompletedEvent и после этого возвращается к вашему коду.

for (int i = 0; i < 999999; ++i)
{
    System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback((x) =>
    {
        while (backgroundWorker1.IsBusy && backgroundWorker2.IsBusy)
        {
            System.Threading.Thread.Sleep(0);
        }
        // Code that is beging executed after all threads have ended. 
        myCode();
    }));

    if (!backgroundWorker1.IsBusy)
    {
        backgroundWorker1.RunWorkerAsync();
    }
    else if (!backgroundWorker2.IsBusy)
    {
        backgroundWorker2.RunWorkerAsync();
    }        
}