Arrêt d'un thread lorsque la commande d'annulation est déclenchée par l'utilisateur

Question

L'application mobile permet à l'utilisateur de télécharger la pièce jointe à partir de la télécommande.Connexion avec un serveur distant et le téléchargement du contenu s'effectue dans un thread séparé. montré à l'utilisateur avec la commande d'annulation. Ici, je fournis le pseudo code.

new Thread(new Runnable() 
    public void run(){ 
    try{ 
    //open connection to remote server 
    //get data input stream 
    //create byte array of length attachment size 
    //show modeless dialog with the message "Downloading..." 
    for(int i=0;i<attachmentSize;i++){ 
     //set the progress indicator of the modeless dialog based upon for iteration 
     //read the byte from input stream and store it in byte array 
    } 
     //open file connection outputstream and store the downloaded content as a file in mobile file system 
     //show dialog with the message "attachment successfully downloaded" 
     } 
     catch(IOException ioe) { } 
     catch(Exception ex) { } 
    } 
).start(); 

Maintenant, je suis en train d'ajouter une commande d'annulation à la boîte de dialogue avec indicateur de progression. Lorsque l'utilisateur clique sur la commande "Annuler" dans un mobile, une boîte de dialogue non modale peut être supprimée en appelant la méthode dispose(). Comment puis-je arrêter brusquement le thread qui reçoit les pièces jointes par e-mail en streaming? Merci de m'aider à résoudre ce problème.

Answer 1

Je ne suis pas un expert dans ce domaine, alors prenez ma suggestion avec un grain de sel, car mon expérience est très limitée sur les threads Java.

Vous ne pouvez pas arrêter un thread en cours d'exécution. Vous pouvez simplement le quitter dès que possible. Donc, ce que vous pouvez faire est d'avoir, par exemple, un drapeau partagé que vous testez périodiquement dans le thread secondaire. Lorsque le thread principal le définit en réponse à un clic Annuler, le thread secondaire retourne.

Answer 2

Vous pouvez l'arrêter brusquement - mais cela pose plus de problèmes que cela en vaut la peine.

La façon canonique de le faire est d'avoir un drapeau qui est vérifié dans le Runnable:

public class ClassHoldingRunnable { 

    private volatile boolean stopRequested = false; 

    public void executeAsync() { 

     Runnable r= new Runnable() { 

      public void run() { 

       while (!stopRequested) { 
        // do work 
       } 
      } 
     } 

     new Thread(r).start(); 
    } 

    public void cancel() { 
     stopRequested = true; 
    } 
} 

Quelques notes:

• il est vital pour le drapeau stopRequested être soit volatile ou d'avoir une autre garantie de visibilité (synchronized, Lock, Atomic) car il est accédé par plusieurs threads;
• vous devriez vérifier stopRequested assez souvent s'il est important pour l'utilisateur final d'avoir une interface graphique réactive;

Answer 3

Mon expérience est plus en C#, mais cela pourrait encore être applicable ...

Je ne pense pas que ce soit une bonne idée de trouver un moyen de simplement « tuer un fil » plus que vous le feriez il suffit de supprimer un objet et d'ignorer son destructeur.

Vous pouvez dire au thread de se suicider via une interruption. Vous pouvez alors utiliser le drapeau interrompu du thread comme indicateur ou, si vous avez un sleep/wait dedans, vous pourriez attraper une exception interrompue et vous arrêter correctement quand ceci est attrapé (dans le bloc finally). Cela devrait fournir, plus ou moins, ce que vous cherchez.

Answer 4

Il existe plusieurs façons complémentaires d'interrompre un thread lu à partir d'une connexion.

• Vous lisez probablement les données à distance en boucle sur un seul appel à InputStream.read, de sorte que vous pouvez réutiliser un seul, relativement faible, octet [] objet. Vous pouvez vérifier une variable membre booléenne avant chaque itération. Vous n'avez pas vraiment besoin de synchroniser autour de ce booléen car il n'est supposé changer de valeur qu'une fois après la construction du Thread. La fermeture de la connexion signifie que votre thread lancera une exception IOException lorsqu'il tentera d'y accéder. Une implémentation JavaME correcte ne créera pas de connexion.close() block même si un autre Thread lit à partir de InputStream de la Connection.