Thread beenden

ChrisPlusPlus

Hallo!

Ich möchte einen Thread mit

protected void ThreadKill()
{
     _th.Abort();   // _th (Thread), hier starte ich die Thread-Beendigung
     _th.Join();    // und warte, bis der Thread beendet ist
}

vorzeitig beenden. Das klappt im Debug-modus auch einwandfrei, jedoch im Release-Modus kracht es.

Woran liegt das? Hat jemand eine Ahnung?

Headhunter

Hallo,

wenn du einen Thread mit Abort beenden möchtest, so musst du in der Funktion eine ThreadAbortException abfangen. Das geht am einfachsten, indem du deinen ganzen asynchronen Quellcode in nen try/catch Block schiebst.
Danach sollte es nicht mehr "krachen".

ChrisPlusPlus

Hört sich gut an und werde es ausprobieren!

Jedoch habe ich bemerkt, daß dies auch im debug-modus so geschieht. Und zwar kracht es explizit in einer Berechnungsfunktion die etwas rechenintensiver ist.

Und zwar wie folgt:
Ich beenden den Thread, wie beschrieben, jedoch läuft die (rechenintensive) Berechnung noch so lange fort, bis sie abgeschlossen ist. Jedoch ist zu diesem Zeitpunkt der Thread schon beendet (der diese Berechnung angestoßen hat).

Hmmm ... ist dieser umstand auch mit der von Dir beschrieben Vorgangsweise zu handhaben???

Headhunter

Hallo Chris,

das Verhalten, das du beobachtest, ist durchaus normal.
Threads können erst nach erreichen eines gewissen "Safepoints" beendet werden.
Wann dann das der Fall ist entscheidet die CLR, nicht du. Wenn du jedoch unsafe Code aufrufst oder auf COM Objekte zugreifst, kann der Thread erst beendet werden wenn diese Berechnungen abgeschlossen sind.
Du musst wohl die Threadenden synchronisieren. Also in deinem Mainthread per Join auf die Worker warten. Oder du setzt den Workerthreads die Property IsBackground auf false, dann kannst du dir das Join sparen.

Davon abgesehen ist "es kracht" keine sehr detaillierte Fehlerbeschreibung. Was funktioniert denn nicht?

ChrisPlusPlus

Hallo!

Nun ich arbeite mit verwaltetem Code und rufe nach beenden des Threads mit Abort() umgehend Join() auf.

Nichtsdestotrotz, kracht es und zwar im Code der Berechnung. Ich verstehe das nicht!

Headhunter

Meine Kristallkugel sagt mir.. gar nichts, ich habe nämlich keine. Kannst du mal etwas von dem relevanten Code posten, so dass man sich das mal anschauen kann?

ChrisPlusPlus

Es gibt eine kleine Besonderheit in meinem Code, nämlich daß ich den Thread als nicht statischen Member verwende. Vielleicht liegt es daran.
Guten Morgen!

Bei der Ausführung(!) von folgendem Code kracht es in der im Thread aufgerufenen Berechnungsfunktion(!):

Die sensiblen Codestellen habe ich mit 10 Rufzeichen gekenntzeichnet.

public void Kill()
{
    bool doAction = true;
    switch(_threadState)     //	ThreadStates is a selfdefined enum!!!
    {
        case ThreadStates.Suspended:	
        {
            doAction = true;
            //	let the thread temporarely resume its work.
            //	it will be killed at soon.
            _th.Resume();
            break;
        }

        case ThreadStates.Running:
        {
            doAction = true;
            break;
        }

        case ThreadStates.Unstarted:
        {
            doAction = false;
            break;
        }

        case ThreadStates.Finished:
        {
            doAction = false;
            break;
        }
    }
    if(doAction)
    {
        _th.Abort();    // !!!!!!!!!!
        _th.Join();     // !!!!!!!!!!
        _threadState = ThreadStates.Finished;
    }
}

Headhunter

Guten Morgen,

leider sehe ich in deinem Codeschnipsel nichts, was irgendwie relevant zu deinem Problem sein könnte. Du könntest die hässliche switch Bedingung in ein if/else umwandeln, sieht schöner aus.
Nochmal: Im Thread musst du die ThreadAbortException abfangen, das geht indem du sämtlichen Inhalt deiner Threadfunktion in einen Try/Catch Block schiebst. Mit Instanzfunktion oder nicht hat das nichts zu tun.

ChrisPlusPlus

Meinst Du den Inhalt der Work-Funktion???

public void Start()
{
    bool doAction = true;
    switch(_threadState)
    {
        case ThreadStates.Suspended:
        {
            doAction = false;
            break;
        }

        case ThreadStates.Running:
        {
            doAction = false;
            break;
        }

        case ThreadStates.Finished:
        {
            _th = new Thread(Work);    // Den Inhalt der Work-Funktion????
            doAction = true;
            break;
        }
    }
    if(doAction)
    {
        _th.Start();
        _threadState = ThreadStates.Running;
    }
}

Switch-case-Anweisungen mögen ja hässlich sein, sind aber das vorgesehene Konstrukt bei einer Mehrfachauswahl