Démarrer le thread avec un temps d'exécution donné

Question

Mon processus principal appelle une méthode de bibliothèque externe. Cette méthode est parfois bloquée. Je ne peux pas réparer la bibliothèque externe car une autre société en est responsable.

Je souhaite utiliser un thread pour les appels de bibliothèque avec un temporisateur d'exécution défini. Lorsque l'appel de méthode prend trop de temps, le thread avec le Runnable dans lequel l'appel de méthode est placé devrait s'arrêter et le processus principal devrait aller de l'avant.

1. thread principal attente
2. Execute Discussion
   • début ACT.TEMPOR Discussion
   • Quand le fil de la minuterie est terminée tuer Exécuter fil
3. Exécuter fin de filet CV principal fil

Quelqu'un a-t-il du code pour cette logique, un motif de design que je peux utiliser ou une page internet? Je peux lire quelques informations?

Merci

Answer 1

Jetez un oeil au package java.lang.concurrent dans Java 5 et versions ultérieures, en particulier l'interface CompletionService et les classes qui l'implémentent.

Cette interface inclut les appels qui vous permettent de soumettre une tâche et d'attendre qu'elle se termine ou de continuer après un délai d'expiration.

Answer 2

Cela va attendre jusqu'à 30 secondes pour que le fil finisse.

Thread t = new Thread() { 
    public void run() { 
    badExternalMethod(); 
    synchronized (this) { 
     notifyAll(); 
    } 
    } 
}; 

synchronized (t) { 
    t.start(); 
    try { 
    t.wait(30000); // 30 secs 
    } catch (InterruptedException e) { 
    e.printStackTrace(); 
    } 
} 

// t a terminé ou expiré

Answer 3

Vous ne serez pas en mesure de faire comme par magie l'arrêt de fil conducteur au bout de 30 secondes; ce que vous devez faire est de vérifier que le thread vérifie un certain état après la fin du temps, notez qu'il est trop long et que sa méthode d'exécution est return.

Il y a à peu près deux façons de faire cela:

1. Demandez le fil d'appel de la bibliothèque effectuer ses opérations en « morceaux » qui prennent de petites quantités de temps chacun, et vérifier l'état entre chaque morceau. Si vous traitez des centaines de milliers d'enregistrements, par exemple, vous pouvez traiter quelques centaines en un seul lot, puis vérifier le drapeau. Ou si vous effectuez des appels potentiellement bloquants avec un délai d'attente disponible, définissez le délai d'attente sur 500 ms et vérifiez le drapeau entre chaque appel. Si le thread principal interrompt le thread d'appel de la bibliothèque lorsque le temps est écoulé, assurez-vous que le thread de bibliothèque gère correctement les interruptions et vérifie le drapeau lorsque c'est le cas. Cela nécessiterait que le thread d'appel de bibliothèque effectue une méthode interruptible, bien que toute méthode potentiellement longue devrait permettre des interruptions.

Dans les deux cas, vous aurez besoin d'avoir l'un des fils (probablement le fil principal car il n'a rien d'autre à faire) définir l'indicateur « Stop » pour true une fois que le temps est écoulé (et cette variable devrait être déclaré volatile afin que les mises à jour soient vues par tous les threads). De même, lorsque le thread d'appel de bibliothèque voit cet indicateur comme vrai, il doit arrêter ce qu'il fait, généralement en retournant de la méthode run().

Vous ne devriez pas vraiment tuer le thread de bibliothèque du thread principal; voir Why are Thread.stop, Thread.suspend and Thread.resume Deprecated pour les raisons, et une alternative qui ressemble beaucoup à ce que j'ai décrit ci-dessus.:-)