Comment les Java Shutdown Hooks peuvent-ils être utilisés pour garantir un arrêt progressif de l'application et gérer le traitement par lots dans un fichier ?

Java Shutdown Hooks : mise en œuvre pratique

Dans le développement de logiciels, l'arrêt progressif fait référence à la pratique consistant à mettre fin à une application avec une interruption minimale. Les hooks d'arrêt sont un mécanisme Java qui permet aux applications d'effectuer des tâches de nettoyage et d'assurer un arrêt progressif.

Comprendre les hooks d'arrêt

Les hooks d'arrêt sont des objets exécutables enregistrés auprès de la machine virtuelle Java (JVM). . Lorsque la JVM entre dans la séquence d'arrêt, tous les hooks enregistrés sont exécutés dans un ordre non spécifié. Les hooks peuvent être utilisés pour effectuer des tâches telles que la fermeture des descripteurs de fichiers, la libération des connexions à la base de données et l'exécution d'autres opérations d'arrêt nécessaires.

Utiliser les hooks d'arrêt en pratique

Pour utiliser efficacement les hooks d'arrêt, il est important de comprendre comment ils interagissent avec le cycle de vie de l'application. Les hooks d'arrêt sont généralement enregistrés lors de l'initialisation de l'application. Lorsque l'application s'arrête, la JVM déclenche l'exécution de tous les hooks dans un thread séparé.

Voici une version révisée du code fourni qui montre comment implémenter un hook d'arrêt pour gérer gracieusement le traitement par lots dans un fichier. :

<code class="java">public class GracefulShutdownTest2 {
    final private int N;
    final private File f;
    private volatile boolean keepRunning = true;

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

    public void run() {
        PrintWriter pw = null;
        try {
            FileOutputStream fos = new FileOutputStream(this.f);
            pw = new PrintWriter(fos);
            for (int i = 0; i < N && keepRunning; ++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(' ');
            }
        }
    }

    private void registerShutdownHook() {
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                keepRunning = false;
                try {
                    Thread.currentThread().join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }

    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 GracefulShutdownTest2(
                    new File(args[0]),
                    Integer.parseInt(args[1])
            ).run();
        }
    }
}</code>

Dans ce code, l'indicateur keepRunning est utilisé pour indiquer que l'application doit continuer à traiter les lots. Le hook d'arrêt définit cet indicateur sur false et attend que le thread principal termine le traitement du lot en cours avant de terminer l'application.

En utilisant des hooks d'arrêt, les développeurs peuvent garantir que les tâches critiques sont terminées correctement, même si l'application est terminé prématurément. Cela permet de maintenir l'intégrité des données et d'améliorer l'expérience utilisateur en empêchant l'arrêt brutal du programme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!