Java: la Force de l'arrêt de ExecutorService fils

Mon code:


String[] torrentFiles = new File("/root/torrents/").list();

        if(torrentFiles.length == 0 || torrentFiles == null)
        {
            System.exit(0);
        }

        ex = Executors.newFixedThreadPool(3);

        for(String torrentFile : torrentFiles)
        {
            ex.submit(new DownloadTorrent("/root/torrents/" + torrentFile));
        }

        ex.shutdown();

        try
        {
            ex.awaitTermination(30, TimeUnit.MINUTES);
        }
        catch(InterruptedException ex1)
        {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex1);
        }

Mais parfois torrent téléchargement prend du temps inconnu de la valeur et de la «awaitTermination» ne fonctionne comme je veux. J'ai besoin d'arrêter tous les threads exécutés immédiatement après une demi-heure, mais comme je sais «awaitTermination» uniquement utiliser interrupt() méthode qui ne fonctionne que dans des boucles ou en attente. Donc, délai d'attente fonctionne pas si ce moment arrive. Alors, comment?

OriginalL'auteur Clark | 2011-05-10

6

ExecutorService.shutdownNow() vais essayer d'arrêter tous de l'exécution de threads..

Voici une citation de javadoc

List<Runnable> shutdownNow()

Essaie d'arrêter tous les activement
de l'exécution des tâches, arrête le traitement
des tâches en attente, et renvoie une liste
des tâches qui ont été en attente d'
l'exécution.

Il n'y a pas de garanties
au-delà de best-effort des tentatives d'arrêt
traitement activement à l'exécution des tâches.
Par exemple, les implémentations
annuler via le Fil de discussion.interrupt(), de sorte
si toutes les tâches de masque ou de ne pas répondre
les interruptions, ils peuvent ne jamais
mettre fin.

Je suis également en utilisant shutdownNow() pour arrêter tous les autres l'exécution de threads, mais je suis capable d'arrêter un thread qui est en attente d'une réponse du service. Si j'ai mis le fil de dormir, puis il s'arrête immédiatement, mais dans le précédent cas, il ne le fait pas. Est-il une raison spécifique pour cela?
oui il y a des raisons pour que cela se produise. Fil de discussion.sleep() vérifie l'interruption d'état et si le thread est déjà interrompu , il jette alors InterruptedException. Toutefois, en l'absence de blocage de chose qui se passe, comme indiqué dans la doc , Il n'y a pas de garanties au-delà de best-effort tente d'arrêter le traitement activement à l'exécution des tâches

OriginalL'auteur Manimaran Selvan
7

Instantanée fin des threads n'est jamais garanti, à moins que le fil vérifie périodiquement pour isInterrupted() drapeau (ou est en attente dans interruptable méthode, c'est à dire qui throws InterruptedException).

Envisager la mise en œuvre de votre threads de travail de manière que, lorsqu'ils vérifient périodiquement pour isInterrupted(). Cela peut être quelque chose comme ça:
```
public void run() { 
  byte[] data;
  do {
     data = receiveDataChunk(timeout);
     processData(data);
  } while(!isInterrupted() && data != null);
}
```
OriginalL'auteur weekens
6

Depuis le téléchargement d'un torrent implique sans doute le blocage des opérations d'e /s, il suffit d'appeler cancel()/shutdownNow() ne sera pas suffisant, parce que le blocage des opérations d'e /s ne sont pas garantis à la fin de leurs fils respectifs sont interrompues.

Vous devez également fermer le sous-tendent les prises dans l'ordre d'annuler le blocage de IO, voir Comment mettre fin à un blocage du thread sur socket IO opération instantanément?.

OriginalL'auteur axtavt
1

ExecutorService.soumettre(...) renvoie une Future<?> qui a un cancel() méthode. Vous devez garder une trace de ces peut l'appeler quand vous voulez pour chaque tâche d'arrêter.

Si il n'a pas mis en œuvre un contrôle sur le Thread.interrompu() dans sa mise en œuvre cela n'aura aucun effet.

OriginalL'auteur SimonC

Suis en Utilisant ce code que j'ai créé.

Ses générer des fichiers pdf à partir de nombreux modèles html à l'aide de wkhtmltopdf .

je tiens donc à augmenter les performances de la création de handreds sans garder le client en attente, ce n'est qu'une partie de la mise en œuvre.

Sur getListOfCallables son retour le bon optimale
seuil pour le nombre de threads à utiliser en fixe la création d'un pool.

Donc je ne peux pas gérer d'avoir beaucoup de nations unies dead threads autour de la pose, il fait mon EC2
CPU à 100% coincé.

J'ai utilisé :

shutdown()
shutdownNow() dans le reste de l'attendent
shutdownNow() à l'exception de la partie

Liste fileGenerationHtmlToPdfList = getListOfCallables(chemins d'accès, le nom, options);

            ExecutorService executorService = Executors.newFixedThreadPool(fileGenerationHtmlToPdfList.size());
List<Future<ArrayList<File>>> futures = null;
try {
futures = executorService.invokeAll(fileGenerationHtmlToPdfList);
try {
for(Future f: futures) {
files.addAll((ArrayList<File>)f.get());
}
} catch (InterruptedException ex) {
Logger.getLogger(FileUtil.class.getName()).log(Level.SEVERE, "Interrupted Exception " , ex);
} catch (ExecutionException ex) {
Logger.getLogger(FileUtil.class.getName()).log(Level.SEVERE, "Interrupted Exception " , ex);
}
} catch (InterruptedException ex) {
Logger.getLogger(FileUtil.class.getName()).log(Level.SEVERE, "Interrupted Exception " , ex);
}
executorService.shutdown();//try shutdown
try {
if (executorService.awaitTermination(5, TimeUnit.SECONDS)) {
Logger.getLogger(FileUtil.class.getName()).log(Level.SEVERE, "Done ShutDowned");
} else {
executorService.shutdownNow();
}
} catch (InterruptedException ex) {
executorService.shutdownNow();
Logger.getLogger(FileUtil.class.getName()).log(Level.SEVERE, "Interrupted Exception " , ex);
}

OriginalL'auteur shareef

-1

Maintenant, je dois arrêter les threads d'une piscine. Je suis en train de faire une telle façon. Il est peut-être pas une bonne idée. Commentaire, s'il vous plaît, si.
```
boolean isTerminated = mPoolThreads.isTerminated();
while (!isTerminated) {
mPoolThreads.shutdownNow();
isTerminated = mPoolThreads.isTerminated();
Log.i(Constants.LOG_TAG, "Stop threads: the threads are not terminated yet");
}
Log.w(Constants.LOG_TAG, "Stop threads: Terminated");
```
Je ne suis pas sûr au sujet de la question directe, mais au lieu de la while boucle, un meilleur modèle dans de tels cas (où vous ne pouvez pas savoir juste en regardant le code qu'il va y mettre fin) est-à-dire par exemple for (int retries = 0; retries < 1000; ++retries). Aussi, ajouter 10 ms d'attente entre deux tentatives, ou au moins yield(). Si elle atteint 1000, journal d'une erreur. (Au lieu de 1000, il devrait y avoir un certain nombre qui est tout à fait déraisonnable de s'attendre à ce que si, il s'est comporté correctement.)

OriginalL'auteur Maksim Dmitriev

Vous devez vous connecter pour publier un commentaire.