Comment puis-je déterminer efficacement l'état d'achèvement des threads enfants dans la programmation multithread ?

Détermination de l'état d'achèvement des threads

Dans la programmation multithread, il est crucial de savoir quand les threads enfants ont terminé leur exécution. Cette question explore diverses approches pour surveiller l'état d'achèvement des threads.

Thread.join() :
Cette méthode dans le thread principal bloque l'exécution jusqu'à ce que tous les threads enfants soient terminés. Il garantit un achèvement synchronisé mais constitue une approche bloquante.

Thread.isAlive() :
Polling Thread.isAlive() vous permet de vérifier si un thread est toujours en cours d'exécution. Cependant, il est recommandé d'éviter l'interrogation car elle est inefficace et peut avoir un impact sur les performances.

Gestion des exceptions :
Dans une approche non conventionnelle, vous pouvez configurer la gestion des exceptions non interceptées pour chaque thread. Une fois le thread terminé, il génère une exception qui peut être gérée dans votre objet principal.

Utilitaires simultanés :
Les utilitaires simultanés de Java tels que les verrous et les synchroniseurs peuvent être utilisés pour coordonner l'exécution du thread. et établir des dépendances.

Achèvement du fil de discussion Listener :

Une approche plus orthodoxe consiste à créer une interface d'écoute :

public interface ThreadCompleteListener {
    void notifyOfThreadComplete(final Thread thread);
}

Ensuite, définissez une classe de thread de base abstraite qui étend Thread et implémente les méthodes suivantes :

public abstract class NotifyingThread extends Thread {
    private final Set<ThreadCompleteListener> listeners = new CopyOnWriteArraySet<>();

    public final void addListener(final ThreadCompleteListener listener) {
        listeners.add(listener);
    }

    public final void removeListener(final ThreadCompleteListener listener) {
        listeners.remove(listener);
    }

    private final void notifyListeners() {
        for (ThreadCompleteListener listener : listeners) {
            listener.notifyOfThreadComplete(this);
        }
    }

    @Override
    public final void run() {
        try {
            doRun();
        } finally {
            notifyListeners();
        }
    }

    public abstract void doRun();
}

Chaque thread enfant doit étendre NotifyingThread et implémenter doRun() au lieu de run(). Une fois terminé, le fil appelle automatiquement notifyListeners().

Dans votre classe principale, implémentez ThreadCompleteListener et ajoutez-vous en tant qu'auditeur lors de la création de chaque fil :

NotifyingThread thread1 = new OneOfYourThreads();
thread1.addListener(this); // add ourselves as a listener
thread1.start(); // Start the Thread

Lorsque chaque fil est terminé, le La méthode notifyOfThreadComplete est invoquée, donnant accès à l'instance de thread terminée.

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!