Anmutig Herunterfahren ein Programm mit mehreren threads mit unendlichen while-Schleife

Ich habe ein Programm erstellt 10 threads, und jeder thread hat eine endlos laufende while-Schleife.
Ich brauche Hilfe, um effizient zu implementieren, ein Shutdown-hook, mit dem wirksam BEENDEN aller threads. Da will ich tun, um ein ordnungsgemäßes Herunterfahren jeder Thread beendet werden soll, sobald er feststellt das stop-flag gesetzt hat, zu WAHREN.

public class SampleGSH implements Runnable{
    private static boolean stop = false;
    public static void main(String[] args) {
        for(int i = 0; i < 10;i++) {
            Thread t = new Thread(new SampleGSH(), "name"+i);
            t.start();
        }
    }

    @Override
    public void run() {
            Runtime.getRuntime().addShutdownHook(new Thread("shutdown thread") {
                public void run()
                {
                    System.out.println("*******");
                    synchronized (this) 
                    {
                        System.out.println("Turning switch off");
                        stop = true;
                    }
                }
            });

            synchronized (this) {
                while(!stop)
                {
                      //Some logic which should not be killed abruptly once it starts running, a graceful shut down will not allow this code to start
                }
            }   
    }
}

Jede Hilfe wird wirklich geschätzt.

InformationsquelleAutor Suyog Barve | 2013-05-05

2

Dies ist eine FAQ. Wenn Sie alle Felder, die von mehreren threads gemeinsam genutzt, müssen Sie synchronisiert werden. In diesem Fall ist Ihr stop sollte volatile. Ohne diese, gibt es nichts, das dafür sorgt, dass die threads sehen den Wert von stop änderung true. Sehen dieses tutorial für Informationen über Atomare Zugriff.

Finden Sie unter: Boolesche var für das stoppen von threads

Paar andere Kommentare:
- Wenn Sie beginnen eine Anzahl von threads, sollten Sie erwägen, einen ExecutorService
- Ihre while loop ist innen aus einem synchronized block. Dieses tut nichts mehr, und die stop Feld nicht get-Speicher synchronisiert, da es aktualisiert wird außen, während im inneren des Blocks.
- Einen anderen Weg zu stoppen, wäre ein thread zu interrupt() es. Sehen dieses tutorial.
```
while (!thread.currentThread().isInterrupted()) {
    ...
}
...
t.interrupt();
```
InformationsquelleAutor Gray
1

Vergessen, dass addShutdownHook guff ... keep it simple ...
1. Machen die statischen stop variable flüchtigen ...
2. dann fügen Sie diese Methode, um SampleGSH ...
  
  public void shutdown() { stop = true; }
3. dann nennen, wenn Sie wollen, zu stoppen der threads!
- Nein, Sie können nicht vermeiden, dass addShutdownHook, weil Ihr die einzige Möglichkeit, um benachrichtigt zu werden, wenn service-getötet von OS
InformationsquelleAutor xagyg

Statt einer einzigen static boolean stop, Sie geben jedem thread eine eigene Haltestelle boolean. Speichern Sie dann alle thread-Objekte erstellen, wenn Sie Sie und setzen Sie Ihre stop-boolean true in der shutdown-hook-thread (das würde süchtig werden in der main-Methode).

Etwas wie dieses:

import java.util.ArrayList;
import java.util.List;

public class SampleGSH extends Thread {

    public boolean stop = false;
    private static List<SampleGSH> threads = null;

    public static void main(String[] args) {

        threads = new ArrayList<SampleGSH>();

        int numThreads = 10;
        for (int i = 0; i < numThreads; i++) {
            SampleGSH t = new SampleGSH();
            threads.add(t);
            t.start();
        }

        Runtime.getRuntime().addShutdownHook(new Thread("shutdown thread") {
            public void run() {
                System.out.println("*******");
                for (SampleGSH t : threads) {
                    t.stop = true;
                }
            }
        });
    }

    @Override
    public void run() {
        {
            while (!stop) {
                //Some logic which should not be killed abruptly once it starts
                //running, a graceful shut down will not allow this code to
                //start
            }
        }
    }
}

Oder nutzen Sie einfach thread.interrupt() und thread.isInterrupted () - Methode statt, da @Gray schlägt.

InformationsquelleAutor Barry NL

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.