it-swarm.com.de

Thread.stop () - veraltet

Warum ist Thread.stop() in Java veraltet? Auf ihrer Website sehe ich Folgendes:

Warum ist Thread.stop Veraltet?

Weil es von Natur aus unsicher ist. Durch das Stoppen eines Threads werden alle gesperrten Monitore entsperrt. (Die Monitore werden entsperrt, da die ThreadDeath - Ausnahme den Stapel weitergibt.) Wenn sich eines der zuvor von diesen Monitoren geschützten Objekte in einem inkonsistenten Zustand befand, können diese Objekte jetzt von anderen Threads in einem inkonsistenten Zustand angezeigt werden. Solche Gegenstände sollen beschädigt sein. Wenn Threads mit beschädigten Objekten arbeiten, kann dies zu willkürlichem Verhalten führen. Dieses Verhalten kann subtil und schwer zu erkennen sein oder es kann ausgeprägt sein. Im Gegensatz zu anderen ungeprüften Ausnahmen beendet ThreadDeath Threads stillschweigend. Daher hat der Benutzer keine Warnung, dass sein Programm möglicherweise beschädigt ist. Die Beschädigung kann sich jederzeit nach dem tatsächlichen Schaden bemerkbar machen, auch nach Stunden oder Tagen in der Zukunft.

Ich verstehe nicht, was sie mit "Monitoren" meinen. Unabhängig davon ist meine Frage, ob Thread.stop() nicht aufgerufen werden soll. Wie soll dann ein Java Thread gestoppt werden?

43
user2374107

Du hast gefragt:

Meine Frage ist, ob es keine Möglichkeit gibt, einen Thread in Java zu stoppen, wie man dann einen Thread stoppt?

Die Antwort: In Java) gibt es keine saubere, schnelle oder zuverlässige Möglichkeit, einen Thread zu stoppen.

Der Threadabschluss ist nicht so einfach. Ein laufender Thread, der von vielen Autoren oft als leichter Prozess bezeichnet wird, hat einen eigenen Stapel und ist der Meister seines eigenen Schicksals (auch Dämonen). Es kann Dateien und Sockets besitzen. Es kann Schlösser halten. Abrupte Beendigung ist nicht immer einfach: Es können unvorhersehbare Folgen auftreten, wenn der Thread gerade eine Datei schreibt und beendet wird, bevor er den Schreibvorgang beenden kann. Oder was ist mit den Monitorverschlüssen, die der Faden hält, wenn er in den Kopf geschossen wird?

Stattdessen stützen sich Threads auf einen kooperativen Mechanismus, der als Unterbrechung bezeichnet wird. Dies bedeutet, dass Threads nur signalisieren können andere Threads zum Stoppen zwingen können, nicht zum Stoppen.

Um Threads in Java zu stoppen, setzen wir auf einen kooperativen Mechanismus namens Interruption. Das Konzept ist sehr einfach. Um einen Thread zu stoppen, können wir ihm lediglich ein Signal senden, oder ihn unterbrechen und ihn auffordern, sich bei der nächsten verfügbaren Gelegenheit selbst zu stoppen. Das ist alles. Es ist nicht abzusehen, was der Empfänger-Thread mit dem Signal tun könnte: Es könnte sich nicht einmal die Mühe machen, das Signal zu überprüfen. oder noch schlimmer ignorieren.

Quelle: http://10kloc.wordpress.com/2013/03/03/Java-multithreading-steeplechase-stopping-threads/

39
goblinjuice

Der richtige Weg ist die Verwendung eines Joins. Anstatt die Ausführung eines Threads vorzeitig zu stoppen, wartet der Join, bis der Thread die Ausführung beendet hat, bevor er zur nächsten Anweisung wechselt.

Thread exampleThread = new Thread(){
    public void run(){
        try {

            Thread.sleep(2000);

        } catch (InterruptedException ex) {
            //handle the exception
        }
    }
};

exampleThread.start();
exampleThread.join();

Hier wartet exampleThread.join (), bis exampleThread ausgeführt wurde, bevor zur nächsten Anweisung übergegangen wird. Die Aufgabe, sicherzustellen, dass der Thread die Ausführung beendet, liegt jedoch beim Programmierer. Im Grunde gibt es keine Möglichkeit, einen Thread anzuhalten, aber wenn Sie ihn richtig gestalten, sollten Sie den Thread nicht anhalten müssen.

8
Harshal Pandya

Wenn Ihr Thread Interrupts korrekt verarbeitet, sollte es möglich sein, sie mit der ExecutorService-Schnittstelle sofort zu beenden. Gemäß der Oracle-Dokumentation versucht die Methode ExecutorService.shutdownNow(), alle aktiv ausgeführten Aufgaben zu stoppen, ohne auf ihre Beendigung zu warten. Es gibt jedoch keine Garantien, die über die Bemühungen hinausgehen, sie zu stoppen. Hier ist ein Beispielcode:

class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i < 10000000; i++)
            try {
            System.out.println(i + " ThreadID: " + Thread.currentThread().getId());
            if (Thread.interrupted()) 
                    throw new InterruptedException();
            } catch (InterruptedException e) {
                return;
        }   
    }
}

ExecutorService executor = Executors.newFixedThreadPool(3);
            executor.submit(new MyThread());
            executor.submit(new MyThread());
            executor.submit(new MyThread());
            executor.shutdownNow();

Ohne Beendigung sollte jeder Thread 10000000-mal eine Nachricht an die Konsole ausgeben. Die Methode executor.shutdownNow() stoppt sofort alle drei Threads.

7
Tinki

From https://docs.Oracle.com/javase/8/docs/api/Java/lang/Thread.html :

Die meisten Stopp-Verwendungen sollten durch Code ersetzt werden, der lediglich eine Variable ändert, um anzuzeigen, dass der Ziel-Thread nicht mehr ausgeführt werden soll. Der Ziel-Thread sollte diese Variable regelmäßig überprüfen und ordnungsgemäß von seiner Ausführungsmethode zurückkehren, wenn die Variable angibt, dass sie nicht mehr ausgeführt werden soll. Um eine schnelle Kommunikation der Stoppanforderung zu gewährleisten, muss die Variable flüchtig sein (oder der Zugriff auf die Variable muss synchronisiert sein).

3
Akhil Patro