Как полностью «убить» рабочего фонаря?

Question

Я пишу приложение Windows, которое многократно выполняет последовательность цифровых операций ввода-вывода.

Эта последовательность действий начинается, когда пользователь нажимает кнопку «СТАРТ», и это делается фоновым работником в backgroundWorker1_DoWork().

Однако, есть случаи, когда я получаю сообщение об ошибке «Этот рабочий стол в настоящее время .......».

Я имею в виду реализации следующих в коде, используя время цикла, чтобы «убить» фона рабочего до начала другой последовательности действий:

if (backgroundWorker1.IsBusy == true) 
{ 

    backgroundWorker1.CancelAsync(); 
    while (backgroundWorker1.IsBusy == true) 
    { 
     backgroundWorker1.CancelAsync(); 
    } 

    backgroundWorker1.Dispose(); 

} 

backgroundWorker1.RunWorkerAsync(); 

Я думаю, моя основная проблема в том, будет ли backgroundWorker1 будет «убит» в конце концов? Если так будет, потребуется много времени для его завершения?

Будет ли это кодирование заводить меня в бесконечный цикл?

Answer 1

Я считаю, что потоки должны нести ответственность за свои собственные ресурсов, насколько это практически возможно, , включая их собственную жизнь.

Как правило, это плохая идея, чтобы убивать потоки из-за пределов их возможностей. Приложения, которые спроектированы для передачи сообщения в поток для закрытия себя, имеют тенденцию иметь гораздо меньше проблем, связанных с многопоточным поведением.

Поток должен отслеживать указанное сообщение, которое может быть таким же простым, как булево значение, заданное другим потоком и считанное этим потоком мониторинга, своевременно и автоматически закрывать , как только это возможно.

Это означает, что, если он должен искать сообщения:

• в его основной цикл, если таковые имеются.
• периодически в любых длительных циклах.

Поток, закрывающий сообщение, должен ждать (но не останавливать GUI, конечно).

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

Но все же, как правило, проще просто архитектовать приложение, чтобы оставить мастера потоков своей собственной судьбой.

Answer 2

У меня была такая же проблема, я не уверен, поможет ли это, но я предполагаю, что у вашего рабочего рабочего есть петля внутри или она выйдет. Что вам нужно сделать, это поставить свою петлю внутри.

Put внутри фона рабочего:

while (backgroundworker1.CancellationPending == false) 
{ 
    //Put your code in here 
} 

Чтобы убить этого BackgroundWorker, вы можете положить в кнопку:

BackgroundWorker1.CancelAsync() 

Я надеюсь, что это помогает.

Answer 3

Вы можете использовать что-то вроде этого (для получения дополнительной информации о прерывании управляемых потоков и о ThreadAbortException см "Plumbing the Depths of the ThreadAbortException Using Rotor" Крис Sells):

public class AbortableBackgroundWorker : BackgroundWorker 
{ 

    private Thread workerThread; 

    protected override void OnDoWork(DoWorkEventArgs e) 
    { 
     workerThread = Thread.CurrentThread; 
     try 
     { 
      base.OnDoWork(e); 
     } 
     catch (ThreadAbortException) 
     { 
      e.Cancel = true; //We must set Cancel property to true! 
      Thread.ResetAbort(); //Prevents ThreadAbortException propagation 
     } 
    } 


    public void Abort() 
    { 
     if (workerThread != null) 
     { 
      workerThread.Abort(); 
      workerThread = null; 
     } 
    } 
} 

Использование:

backgroundWorker1 = new AbortableBackgroundWorker(); 
//... 
backgroundWorker1.RunWorkerAsync(); 

if (backgroundWorker1.IsBusy == true) 
{ 
    backgroundWorker1.Abort(); 
    backgroundWorker1.Dispose(); 
} 

Answer 4

Я положил одну вместе что (я думаю) делает работу. Пожалуйста, дайте мне знать, если im waaaay выключен. Вот простой пример того, как он работает.

var backgroundWorker = new BackgroundWorker(){WorkerSupportsCancellation = true}; 

backgroundWorker.DoWork += (sender, args) => 
     {     
       var thisWorker = sender as BackgroundWorker; 
       var _child = new Thread(() => 
               { 
                //..Do Some Code 

               }); 
       _child .Start(); 
       while (_child.IsAlive) 
       { 
        if (thisWorker.CancellationPending) 
        { 
         _child.Abort(); 
         args.Cancel = true; 
        } 
        Thread.SpinWait(1); 
       }     
     }; 

backgroundWorker.RunWorkerAsync(parameter); 
//..Do Something... 
backgroundWorker.CancelAsync(); 

Поскольку рабочий фон является частью пула потоков, мы не хотим его прерывать. Но мы можем запустить поток внутри, который мы можем разрешить. Затем BackgroundWorker запускается до тех пор, пока ни один дочерний поток не будет завершен, или мы не сообщаем ему, чтобы убить процесс. Затем фоновый рабочий поток может вернуться в пул чтения. Обычно я завершаю это в классе-помощнике и передаю метод делегата, который я хочу, чтобы фоновый поток запускался в качестве параметра и запускал его в дочернем потоке.

Пожалуйста, сообщите мне, если я ударил головой о стену, но, похоже, она работает нормально. Но это проблема с потоками, это не так. Различные результаты, которые вы можете получить при запуске в разное время.

Answer 5

public class abortableBackgroundworker: BackgroundWorker 
{ 
    public bool Kill = false; 

    protected override void OnDoWork(DoWorkEventArgs e) 
    { 


     var _child = new Thread(() => 
     { 
      while (!Kill) 
      { 

      } 
      e.Cancel = true;//..Do Some Code 

     }); 
     _child.Start(); 
     base.OnDoWork(e); 

    } 



} 

установить убить, чтобы верно убить нить и не проблема прерывания :)