Threading en Java

Question

Je suis en train d'avoir mon principal spawn de fil hors un nouveau fil et, après un certain temps, lever le drapeau d'interruption. Quand il le fait, le fil donné naissance devrait voir le drapeau et se terminer.

Le fil conducteur ressemble à ceci:

final Thread t = new Thread()
{
    @Override
    public void run()
    {
        f();
    }
};
t.start();
try
{
    t.join(time);
    t.interrupt();
    if(t.isAlive())
    {
        t.join(allowance);
        if(t.isAlive())
            throw new Exception();
    }
}
catch(Exception e)
{
    System.err.println("f did not terminate in the alloted time");
}

Et le fil donné naissance a un tas de ce qui suit tout au long de son code dispersa:

if(Thread.interrupted()) return;

Quand je suis en mode débogage, tout fonctionne parfaitement. Le drapeau d'interruption est élevé par le thread principal et est pris par le fil donné naissance. Cependant, en mode de fonctionnement normal le fil donné naissance ne semble pas recevoir le drapeau d'interruption, peu importe combien de temps je mets l'allocation.

Quelqu'un sait-il ce que je fais mal?

Note: J'utilise Ubuntu et je suis tout ensemble de nouveau à quoi que ce soit Linux. Le problème peut-être avec le système d'exploitation? Je ne l'ai pas testé le code sur tout autre système d'exploitation.

Answer 1

Je vous suggère de considérer l'utilisation d'un ExecutorService qui est conçu pour faire ce genre de chose et pourrait vous aider d'autres façons.

ExecutorService service = Executors.newCachedThreadPool();
Future<ResultType> future = service.submit(new Callable<ResultType() {
   public ResultType call() throws Exception {
      // do soemthing
      return (ResultType) ...;
   }
);
// do anything you like until you need to result.
try {
   ResultType result = future.get(5, TimeUnit.SECONDS);
} catch (TimeoutException timedOut) {
  // handle exception
  // cancel the task, interrupting if still running.
  result.cancel(true);
} catch (ExecutionException taskThrewAnException) {
  // handle exception
}
// when you have finished with the service, which is reusable.
service.shutdown();

Answer 2

Voici mes suppositions:

• Lorsque les principaux thread appelle le fil de t.interrupt(); t a déjà terminé l'exécution.
• Lorsque les principaux appels de fil dans le fil interrupted() t il n'y a pas plus d'appels pour vérifier le drapeau ThreadInterruptedException.
• Vous obtenez l'exception à la suite de l'exécution du code? Avez-vous l'exception que vous jetez dans votre code après le temps « allocation » ou vous avez une autre ou similaire comme <=>? Essayez d'écrire le message de l'exception ... pêché

Answer 3

Avez-vous procéder à des contrôles imbriqués de Thread.interrupted ()? Cette méthode efface le drapeau interrompu, de sorte que le second appel retourne faux. Vous pouvez utiliser isInterrupted () à la place.

Answer 4

Il semble que l'appel Thread.interrupted () n'est pas atteint en f ().

Le comportement différent que vous voyez dans les modes de débogage et Run est susceptible d'être due à une condition de course.