Je suis en train de travailler sur un projet en Java où j'ai besoin d'avoir plusieurs tâches en cours d'exécution asynchrone. Je suis amené à croire que l'Exécuteur testamentaire est la meilleure façon pour moi de le faire, donc je vais me familiariser avec elle. (Yay payé pour le savoir!) Cependant, il n'est pas clair pour moi ce que le meilleur moyen est d'accomplir ce que je suis en train de faire.
Pour les besoins de la discussion, disons que j'ai deux tâches en cours d'exécution. Ni devrait mettre fin, et les deux doivent s'exécuter pendant la durée de la vie. Je suis en train d'écrire l'une des principales classe wrapper tels que:
- Si l'une des tâches lève une exception, le wrapper de l'attraper et de le redémarrer la tâche.
- Si la tâche s'exécute à la fin, le wrapper avis et redémarrer la tâche.
Maintenant, il convient de noter que la mise en œuvre pour les deux tâches de placer le code en run() dans une boucle infinie qui ne sera jamais exécuté jusqu'à la fin, avec un bloc try/catch qui doit gérer toutes les exceptions d'exécution sans perturber la boucle. Je suis en train d'ajouter une autre couche de certitude; si j'ai quelqu'un qui me suit fait quelque chose de stupide que les défaites de ces garanties et arrêts de la tâche, l'application doit réagir de façon appropriée.
Est-il une bonne pratique pour gérer ce problème, que des gens plus expérimentés que me recommanderiez?
FWIW, je l'ai fouettée à cette classe de test:
public class ExecTest {
private static ExecutorService executor = null;
private static Future results1 = null;
private static Future results2 = null;
public static void main(String[] args) {
executor = Executors.newFixedThreadPool(2);
while(true) {
try {
checkTasks();
Thread.sleep(1000);
}
catch (Exception e) {
System.err.println("Caught exception: " + e.getMessage());
}
}
}
private static void checkTasks() throws Exception{
if (results1 == null || results1.isDone() || results1.isCancelled()) {
results1 = executor.submit(new Test1());
}
if (results2 == null || results2.isDone() || results2.isCancelled()) {
results2 = executor.submit(new Test2());
}
}
}
class Test1 implements Runnable {
public void run() {
while(true) {
System.out.println("I'm test class 1");
try {Thread.sleep(1000);} catch (Exception e) {}
}
}
}
class Test2 implements Runnable {
public void run() {
while(true) {
System.out.println("I'm test class 2");
try {Thread.sleep(1000);} catch (Exception e) {}
}
}
}
C'est se comporter de la façon dont je le veux, mais je ne sais pas s'il y a des pièges, de l'inefficacité, ou carrément mal de tête d'attente à me surprendre. (En fait, étant donné que je suis nouveau à cela, je serais choqué si il y n'était pas quelque chose de mal/déconseillé à ce sujet.)
Toute idée est la bienvenue.
