Pytanie o czyste zakończenie wątku in.NET

[5]}cóż, niestety w wielowątkowości często trzeba iść na kompromis" snappiness " dla czystości... możesz natychmiast opuścić wątek, jeśli Interrupt go, ale nie będzie zbyt czysty. Więc nie, nie musisz posypywać sprawdzeń _shouldStop co 4-5 linii, ale jeśli przerwiesz wątek, powinieneś obsłużyć wyjątek i wyjść z pętli w czysty sposób.

Update

Nawet jeśli nie jest to wątek zapętlający (tzn. być może jest to wątek, który wykonuje jakiś długotrwały asynchroniczna operacja lub jakiś blok do operacji wejścia), możesz Interrupt to, ale nadal powinieneś złapać ThreadInterruptedException i zamknąć wątek czysto. Myślę, że przykłady, które czytasz, są bardzo odpowiednie.

Aktualizacja 2.0

public class InterruptExample
{
    private Thread t;
    private volatile boolean alive;

    public InterruptExample()
    {
        alive = false;

        t = new Thread(()=>
        {
            try
            {
                while (alive)
                {
                    /* Do work. */
                }
            }
            catch (ThreadInterruptedException exception)
            {
                /* Clean up. */
            }
        });
        t.IsBackground = true;
    }

    public void Start()
    {
        alive = true;
        t.Start();
    }


    public void Kill(int timeout = 0)
    {
        // somebody tells you to stop the thread
        t.Interrupt();

        // Optionally you can block the caller
        // by making them wait until the thread exits.
        // If they leave the default timeout, 
        // then they will not wait at all
        t.Join(timeout);
    }
}

Jeśli anulowanie jest wymogiem rzeczy, którą budujesz, to powinno być traktowane z takim samym szacunkiem, jak reszta kodu-może to być coś, dla czego musisz zaprojektować.

Załóżmy, że Twój wątek robi jedną z dwóch rzeczy przez cały czas.

1. coś związanego z procesorem
2. oczekiwanie na jądro

Jeśli jesteś związany w danym wątku, prawdopodobnie masz dobre miejsce, aby wstawić czek. Jeśli dzwonisz do czyjś kod aby wykonać jakieś długo działające zadanie związane z CPU, możesz potrzebować naprawić Zewnętrzny kod, przenieść go z procesu (przerywanie wątków jest złe, ale przerywanie procesów jest dobrze zdefiniowane i bezpieczne), itp.

Jeśli czekasz na jądro, to prawdopodobnie jest uchwyt (lub fd, lub mach port, ...) zaangażowany w oczekiwanie. Zazwyczaj, jeśli zniszczysz odpowiedni uchwyt, jądro natychmiast powróci z jakimś kodem błędu. Jeśli jesteś w. Net / java / etc. prawdopodobnie skończysz z wyjątek. W języku C, jakikolwiek kod, który już masz na miejscu, aby obsłużyć awarie wywołań systemowych, będzie propagować błąd aż do znaczącej części aplikacji. Tak czy inaczej, wyłamujesz się z niskopoziomowego miejsca dość czysto i w bardzo terminowy sposób, bez potrzeby stosowania nowego kodu rozsypanego wszędzie.

Taktyką, której często używam w tego rodzaju kodzie, jest śledzenie listy uchwytów, które muszą zostać zamknięte, a następnie ustawienie przez moją funkcję abort znacznika "anulowane", a następnie ich zamknięcie. Gdy funkcja awarie może sprawdzić flagę i zgłosić awarię z powodu anulowania, a nie z powodu określonego wyjątku / errno.

Wydaje się sugerować, że akceptowalna szczegółowość odwołania jest na poziomie połączenia serwisowego. To chyba nie jest dobre myślenie-o wiele lepiej jest anulować pracę w tle synchronicznie i połączyć Stary wątek tła z wątkiem pierwszoplanowym. Jest o wiele czystszy Bo:

1. Unika klasy rasy Warunki, gdy stare wątki bgwork wracają do życia po nieoczekiwanych opóźnieniach.

2. Pozwala to uniknąć potencjalnych ukrytych wycieków wątku / pamięci spowodowanych wiszącymi procesami tła, umożliwiając ukrycie efektów wiszącego wątku tła.

Istnieją dwa powody, aby bać się tego podejścia:

1. Nie sądzisz, że możesz przerwać swój własny kod w odpowiednim czasie. Jeśli anulowanie jest wymogiem Twojej aplikacji, decyzja, której naprawdę potrzebujesz aby to zasób / decyzja biznesowa: zrobić hack, lub naprawić swój problem czysto.

2. Nie ufasz kodowi, który dzwonisz, bo jest poza Twoją kontrolą. Jeśli naprawdę mu nie ufasz, rozważ przeniesienie go poza proces. Uzyskasz znacznie lepszą izolację od wielu rodzajów ryzyka, w tym tego, w ten sposób.

Być może częścią problemu jest to, że masz tak długą pętlę metody / while. Niezależnie od tego, czy masz problemy z gwintowaniem, powinieneś podzielić je na mniejsze etapy przetwarzania. Załóżmy, że te kroki To Alpha (), Bravo (), Charlie () i Delta().

Możesz wtedy zrobić coś takiego:

    public void MyBigBackgroundTask()
    {
        Action[] tasks = new Action[] { Alpha, Bravo, Charlie, Delta };
        int workStepSize = 0;
        while (!_shouldStop)
        {
            tasks[workStepSize++]();
            workStepSize %= tasks.Length;
        };
    }

Więc tak, pętle bez końca, ale sprawdza, czy nadszedł czas, aby zatrzymać się między każdym krokiem biznesowym.

Nie musisz posypywać, gdy pętle są wszędzie. Zewnętrzna pętla while sprawdza tylko, czy powiedziano jej, aby się zatrzymała, a jeśli tak, to nie robi kolejnej iteracji...

Jeśli masz prosty wątek "go do something and close out" (nie ma w nim pętli), po prostu sprawdź wartość logiczną _shouldstop przed lub po każdym głównym miejscu wewnątrz wątku. W ten sposób wiesz, czy powinno się kontynuować, czy wycofać się.

Na przykład:

public void DoWork() {

  RunSomeBigMethod();
  if (_shouldStop){ return; }
  RunSomeOtherBigMethod();
  if (_shouldStop){ return; }
  //....
}

Najlepsza odpowiedź w dużej mierze zależy od tego, co robisz w wątku.

• Jak powiedziałeś, większość odpowiedzi obraca się wokół ankietowania wspólnego logicznego co kilka linijek. Chociaż może Ci się nie spodobać, często jest to najprostszy schemat. Jeśli chcesz ułatwić sobie życie, możesz napisać metodę taką jak Throwifcanceled (), która rzuca jakiś wyjątek, jeśli skończysz. Puryści powiedzą, że jest to (gasp) użycie wyjątków dla przepływu sterowania, ale potem znowu cacelling jest wyjątkowa imo.

• Jeśli wykonujesz operacje We / Wy (np. sieciowe), możesz rozważyć wykonanie wszystkiego przy użyciu operacji asynchronicznych.

• Jeśli robisz sekwencję kroków, możesz użyć mnogiej sztuczki, aby stworzyć maszynę stanową. Przykład:

abstract class StateMachine : IDisposable
{
    public abstract IEnumerable<object> Main();

    public virtual void Dispose()
    {
        /// ... override with free-ing code ...
   }

   bool wasCancelled;

   public bool Cancel()
   {
     // ... set wasCancelled using locking scheme of choice ...
    }

   public Thread Run()
   {
       var thread = new Thread(() =>
           {
              try
              {
                if(wasCancelled) return;
                foreach(var x in Main())
                {
                    if(wasCancelled) return;
                }
              }
              finally { Dispose(); }
           });
       thread.Start()
   }
}

class MyStateMachine : StateMachine
{
   public override IEnumerabl<object> Main()
   {
       DoSomething();
       yield return null;
       DoSomethingElse();
       yield return null;
   }
}

// then call new MyStateMachine().Run() to run.

>

Zamiast dodawania pętli while, do której pętla nie należy, dodaj coś w rodzaju if (_shouldStop) CleanupAndExit(); tam, gdzie ma to sens. Nie ma potrzeby sprawdzania po każdej operacji lub posypywania ich kodem. Zamiast tego pomyśl o każdej czeki jako o szansie na wyjście z wątku w tym momencie i dodaj je strategicznie, mając to na uwadze.

Wszystkie te odpowiedzi zakładają, że wątek roboczy zostanie zapętlony. That doesn ' t sit comfortably with me

Nie ma zbyt wielu sposobów, aby Kod trwał długo. Zapętlenie jest dość istotną konstrukcją programistyczną. Tworzenie kodu zajmuje dużo czasu bez zapętlania zajmuje ogromną Ilość instrukcji. Setki tysięcy.

Lub wywołanie innego kodu, który robi pętlę za Ciebie. Tak, trudno zatrzymać ten kod na żądanie. To po prostu nie praca.