Exemple utile de hook d'arrêt en Java?

J'essaie de m'assurer que mon application Java prend des mesures raisonnables pour être robuste, et cela implique en partie l'arrêt en douceur. Je lis sur hooks d'arrêt et je ne sais pas vraiment comment les utiliser dans la pratique.

Existe-t-il un exemple pratique?

Disons que j'ai eu une application très simple comme celle-ci ci-dessous, qui écrit des nombres dans un fichier, 10 sur une ligne, par lots de 100, et je veux m'assurer qu'un lot donné se termine si le programme est interrompu. Je comprends comment enregistrer un hook d'arrêt mais je n'ai aucune idée de comment l'intégrer dans mon application. Aucune suggestion?

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();
        }       
    }

    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(' ');
        }
    }

    static public 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();
        }
    }
}

Vous pouvez faire ce qui suit:

• Laissez le hook d'arrêt définir certains AtomicBoolean (ou boolean volatile) "keepRunning" sur false
• (En option, .interrupt les threads de travail s'ils attendent des données dans un appel de blocage)
• Attendez que les threads de travail (s'exécutant writeBatchdans votre cas) se terminent, en appelant leThread.join() méthode sur les threads de travail.
• Terminer le programme

Un peu de code sommaire:

• Ajouter un static volatile boolean keepRunning = true;

• Dans run () vous changez en

  for (int i = 0; i < N && keepRunning; ++i)
      writeBatch(pw, i);

• Dans main () vous ajoutez:

  final Thread mainThread = Thread.currentThread();
  Runtime.getRuntime().addShutdownHook(new Thread() {
      public void run() {
          keepRunning = false;
          mainThread.join();
      }
  });

C'est à peu près comment je fais un gracieux "rejeter tous les clients en frappant Control-C" dans le terminal.

À partir de la documentation :

Lorsque la machine virtuelle commence sa séquence d'arrêt, elle démarre tous les hooks d'arrêt enregistrés dans un ordre non spécifié et les laisse s'exécuter simultanément. Une fois tous les hooks terminés, il exécutera tous les finaliseurs non sollicités si la finalisation à la sortie a été activée. Enfin, la machine virtuelle s'arrêtera.

Autrement dit, un hook d'arrêt maintient la JVM en cours d'exécution jusqu'à ce que le hook soit terminé (renvoyé par la méthode run () .

Les hooks d'arrêt sont des threads non démarrés qui sont enregistrés avec Runtime.addShutdownHook (). JVM ne donne aucune garantie sur l'ordre dans lequel les hooks d'arrêt sont démarrés.Pour plus d'informations, reportez-vous à http://techno-terminal.blogspot.in/2015/08 /shutdown-hooks.html