Wie können Shutdown-Hooks eine ordnungsgemäße Programmbeendigung in Java sicherstellen?

Verwendung von Shutdown-Hooks für eine ordnungsgemäße Programmbeendigung in Java

Shutdown-Hooks bieten einen Mechanismus, um sicherzustellen, dass Java-Anwendungen notwendige Bereinigungsaufgaben ausführen, bevor sie ordnungsgemäß beendet werden. In diesem Artikel befassen wir uns mit der praktischen Anwendung von Shutdown-Hooks und untersuchen ein Szenario, in dem wir sicherstellen möchten, dass Daten vor Programmbeendigung in eine Datei geschrieben werden.

Betrachten Sie die folgende Java-Anwendung:

<code class="java">package com.example.test.concurrency;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;

public class GracefulShutdownTest1 {
    final private int N;
    final private File f;

    public GracefulShutdownTest1(File f, int N) { this.f=f; this.N = N; }

    public void run()
    {
        PrintWriter pw = null;
        try {
            FileOutputStream fos = new FileOutputStream(this.f);
            pw = new PrintWriter(fos);
            for (int i = 0; i < N; ++i)
                writeBatch(pw, i);
        }
        catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        finally
        {
            pw.close();
        }       
    }

    // Write a batch of numbers to the file
    private void writeBatch(PrintWriter pw, int i) {
        for (int j = 0; j < 100; ++j)
        {
            int k = i*100+j;
            pw.write(Integer.toString(k));
            if ((j+1)%10 == 0)
                pw.write('\n');
            else
                pw.write(' ');
        }
    }

    public static void main(String[] args)
    {
        if (args.length < 2)
        {
            System.out.println("args = [file] [N] "
                    +"where file = output filename, N=batch count");
        }
        else
        {
            new GracefulShutdownTest1(
                    new File(args[0]), 
                    Integer.parseInt(args[1])
            ).run();
        }
    }
}</code>

In dieser Anwendung schreiben wir Zahlenstapel in eine Datei. Um sicherzustellen, dass ein Batch abgeschlossen ist, bevor das Programm unterbrochen wird, verwenden wir einen Shutdown-Hook.

Integration eines Shutdown-Hooks

Um einen Shutdown-Hook zu integrieren, gehen Sie wie folgt vor:

1. Registrieren Sie den Shutdown-Hook:Verwenden Sie die Methode Runtime.getRuntime().addShutdownHook(), um den Shutdown-Hook bei der JVM zu registrieren.
2. Implementieren Sie das Herunterfahren Hook: Definieren Sie einen Thread (Unterklassen-Thread), der die Aktionen definiert, die ausgeführt werden sollen, wenn der Hook aufgerufen wird.
3. Im Shutdown-Hook: Setzen Sie ein Flag oder eine atomare Variable auf false um dem Hauptthread zu signalisieren, das Schreiben in die Datei zu stoppen.
4. Im Hauptthread:Überprüfen Sie das Flag oder die atomare Variable innerhalb der Schreibschleife. Wenn es falsch wird, beenden Sie den Schreibvorgang und beenden Sie alle ausstehenden Vorgänge.
5. Threads beitreten: Sobald der Schreibvorgang abgeschlossen ist, treten Sie dem Hauptthread (oder einem anderen Arbeitsthread) bei, um sicherzustellen, dass alle Threads dies getan haben Ausführung abgeschlossen.

Hier ist ein Beispiel:

Fügen Sie eine keepRunning-Variable hinzu:

<code class="java">final static volatile boolean keepRunning = true;</code>

Ändern Sie run() Methode:

<code class="java">//...
for (int i = 0; i < N && keepRunning; ++i)
    writeBatch(pw, i);
//...</code>

Den Shutdown-Hook in main() hinzufügen:

<code class="java">//...
Runtime.getRuntime().addShutdownHook(new Thread() {
    public void run() {
        keepRunning = false;
        mainThread.join();
    }
});
//...</code>

Wenn die JVM ein Shutdown-Signal empfängt (z. B. Strg C ), setzt der Shutdown-Hook keepRunning auf false. Die run()-Methode schreibt dann so lange Daten, bis keepRunning den Wert „false“ hat. Dadurch wird sichergestellt, dass der aktuelle Stapel abgeschlossen ist, bevor das Programm beendet wird.

Das obige ist der detaillierte Inhalt vonWie können Shutdown-Hooks eine ordnungsgemäße Programmbeendigung in Java sicherstellen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!