Comment puis-je interrompre une séquence de procédures en Java?

Question

J'ai un tas de procédures qui doivent être exécutées successivement jusqu'à ce qu'elles soient toutes exécutées ou qu'une certaine condition soit remplie. Voici le code de base qui doit être exécutée jusqu'à ce qu'une condition soit remplie:

public boolean search() 
{ 
    robot.go(); 

    robot.spin(); 

    //etc - around 8 more similar commands (each takes around 2 seconds) 
    return false; //didn't find what it was looking for 
} 

Jusqu'à présent, la seule façon que je l'ai pensé à faire ce que je voulais est ceci:

public boolean search() 
{ 
    robot.go(false); 
    while(robot.isMoving()) 
    { 
     if(thingFound()) 
     { 
      robot.stop() 
      return true; 
     } 
     Thread.yield(); 
    } 

    robot.spin(false); 
    while(robot.isMoving()) 
    { 
     if(thingFound()) 
     { 
      robot.stop() 
      return true; 
     } 
     Thread.yield(); 
    } 


    //etc - around 8 more similar commands 
    return false; //didn't find what it was looking for 
} 

Le false paramètre à go() et spin() indique qu'ils devraient retourner immédiatement, permettant à la condition d'être vérifiée. Cependant, cette approche me semble plutôt inefficace, car le même bloc de code doit être répété 10 fois. Cela pourrait-il être réalisé plus efficacement avec des exceptions ou des threads concurrents?

Answer 1

basé sur Jonathan Leffler answer:
vous pouvez utiliser un Runnable comme pointeur aux commandes

private final Runnable going = new Runnable() { 
    @Override 
    public void run() { 
     robot.go(false); 
    } 
}); 

private final Runnable spinning = new Runnable { 
    @Override 
    public void run() { 
     robot.spin(false); 
    } 
}); 

// other commands 


private boolean isFoundAfter(Runnable command) 
{ 
    command.run(); 
    while (robot.isMoving()) 
    { 
     if (thingFound()) 
     { 
      robot.stop() 
      return true; 
     } 
     Thread.yield(); 
    } 
    return false; 
} 

public boolean search() 
{ 
    if (isFoundAfter(going)) return true; 

    if (isFoundAfter(spinning)) return true; 

    //etc - around 8 more similar commands 
    return false; //didn't find what it was looking for 
} 

une étape supplémentaire, le cas échéant, mettre les commandes dans un tableau ou une Répertoriez-le et exécutez-le en tant que script

... 

private boolean executeSearch(Runnable... commands) 
{ 
    for (Runnable cmd : commands) { 
     if (isFoundAfter(cmd)) return true; 
    } 
    return false; //didn't find what it was looking for 
} 

public boolean search() { 
    return executeSearch(going, spinning /* around 8 more similar commands */); 
} 

Answer 2

Vous ne savez pas pourquoi vous utilisez Thread.yield() - Existe-t-il d'autres threads que vous n'avez pas mentionnés? Ou peut-être que j'ai mal interprété le problème.

Je pense que le modèle de commande pourrait fonctionner ici. Vous auriez une interface RobotCommand avec une méthode execute, et une implémentation de RobotCommand par type de commande (go, spin, etc.). Ensuite, vous pouvez construire un RobotAlgorithm comme List de RobotCommand, et une méthode executeRobotAlgorithm qui itéré la liste, appelant execute sur chaque RobotCommand et vérifier le résultat de thingFound() après chacun.

Édition - oh, je pense que je comprends. Est-ce que go et spin lancent des discussions qui changent l'état du robot, ou quelque chose comme ça?

Edit 2 - en réponse à votre commentaire, il semble que le problème ici est que vous devez être en mesure de revenir immédiatement si le robot trouve ce qu'il cherche, mais le go, spin, commandes, etc gagné » Pour le moment, vous devez pouvoir continuer à exécuter de nouvelles commandes. Donc ce que je pourrais faire ici est d'avoir deux threads - l'un serait un thread "exécuteur" qui exécuterait votre List de RobotCommand s un par un, et un thread "observateur" qui dormira et pollera à plusieurs reprises (vérifier thingFound()). Si thingFound() est toujours vrai alors vous pouvez arrêter votre robot ainsi que le thread exécuteur, ou si l'exécuteur arrive à la fin avant que thingFound() ne soit vrai alors il peut signaler comme tel (si nécessaire).

Answer 3

robot peut utiliser un objet de condition pour signaler au contrôleur qu'il a terminé une sous-tâche ou est entré dans un nouvel état:

http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/locks/Condition.html

intéressant, pour l'environnement qui est en vous pouvez probablement utiliser et notify() et wait() au lieu de la condition plus flexible. Le contrôleur pourrait attendre() que le robot décide de le libérer avec notify().

Answer 4

De toute évidence, la boucle while peut être emballé dans sa propre fonction:

private boolean isFound() 
{ 
    while (robot.isMoving()) 
    { 
     if (thingFound()) 
     { 
      robot.stop() 
      return true; 
     } 
     Thread.yield(); 
    } 
    return false; 
} 

public boolean search() 
{ 
    robot.go(false); 
    if (isFound()) return true; 

    robot.spin(false); 
    if (isFound()) return true; 

    //etc - around 8 more similar commands 
    return false; //didn't find what it was looking for 
} 

(je ne me dérange pas si le conditionnel est réparti sur deux lignes, je ferais probablement que dans le code de production.

Un meilleur programmeur Java que moi peut vous dire si vous pouvez passer des 'procédures' (des pointeurs vers des fonctions, en termes de programmation C). Je suppose que vous pouvez, mais je ne connais pas la syntaxe et les règles. Le evidence semble être que vous ne pouvez pas (vers 2004, de toute façon).