Java ExecutorService mettre en pause/reprendre un thread spécifique

Est-il un moyen d'utiliser ExecutorService pour mettre en pause/reprendre un thread spécifique?

private static ExecutorService threadpool = Executors.newFixedThreadPool(5);

Imaginer que je veux arrêter le fil dont l'id=0 (en supposant que chacun se voit attribuer un id incrémentielle jusqu'à ce que la taille du pool de threads est atteint).

Après un certain temps, en appuyant sur un bouton, disons, je veux la reprendre thread spécifique et de laisser tous les autres threads avec leur statut actuel, qui peut être mis en pause ou reprise.

J'ai trouvé sur la documentation de Java une version inachevée de PausableThreadPoolExecutor. Mais il ne convient pas à ce dont j'ai besoin, car il reprendre tous les threads du pool.

Si il n'y a aucun moyen de le faire avec l'implémentation par défaut de la ExecutorService quelqu'un peut me pointer à une implémentation de Java pour ce problème?

Merci!

Êtes-vous sûr? Fil avec id donné exécute certains choisie au hasard de travail, de sorte que vous êtes à l'arrêt de certaines inconnues de l'emploi. Quel est le sens de le faire?
Imaginez la situation suivante: Vous avez un gestionnaire de téléchargement, et que gestionnaire, vous pouvez arrêter et reprendre les téléchargements. Pour chacun, vous êtes à télécharger les choses, n'a pas d'importance ce ne sont pas pertinentes, et que vous voulez arrêter de télécharger reprendre là où vous le voulez. Cela rend la question plus clair pour vous?
Plus clair, mais toujours pas beaucoup de sens. Arrêter/reprendre des téléchargements est sur une logique d'entreprise, tandis que le pool de threads est sur des ressources de calcul. À la logique de contrôle par ajout/suppression de ressources est une mauvaise idée à mon humble avis.

InformationsquelleAutor Ricardo Santos | 2012-08-11

7

Vous êtes sur la mauvaise voie. Le pool de threads possède les fils et en les partageant avec votre code pourrait gâcher les choses.

Vous devriez vous concentrer sur de faire vos tâches (passé à l'threads annulable/interruptable) et de ne pas interagir avec les threads appartenant à la piscine directement.

En outre, vous ne pouvez savoir à quel type de travail est en train d'être exécutée à la fois que vous essayez d'interrompre le thread, donc je ne vois pas pourquoi vous seriez intéressé à faire cette

Mise à jour:

La bonne façon d'annuler votre tâche présentée dans le pool de threads est par l'intermédiaire de la Future pour la tâche retourné par l'exécuteur testamentaire.

1)de Cette façon, vous savez certainement que la tâche vous réellement but est tenté d'être annulée

2)Si vos tâches sont déjà conçus pour être annulable, alors votre êtes à la moitié du chemin

3) Ne pas utiliser un indicateur pour indiquer une annulation, mais l'utilisation Thread.currentThread().interrupt() au lieu

Mise à jour:
```
public class InterruptableTasks {  
private static class InterruptableTask implements Runnable{  
Object o = new Object();  
private volatile boolean suspended = false;  
public void suspend(){          
suspended = true;  
}  
public void resume(){       
suspended = false;  
synchronized (o) {  
o.notifyAll();  
}  
}  
@Override  
public void run() {  
while(!Thread.currentThread().isInterrupted()){  
if(!suspended){  
//Do work here      
}
else{  
//Has been suspended  
try {                   
while(suspended){  
synchronized(o){  
o.wait();  
}                           
}                       
}  
catch (InterruptedException e) {                    
}             
}                           
}  
System.out.println("Cancelled");        
}
}
/**  
* @param args  
* @throws InterruptedException   
*/  
public static void main(String[] args) throws InterruptedException {  
ExecutorService threadPool = Executors.newCachedThreadPool();  
InterruptableTask task = new InterruptableTask();  
Map<Integer, InterruptableTask> tasks = new HashMap<Integer, InterruptableTask>();  
tasks.put(1, task);  
//add the tasks and their ids
Future<?> f = threadPool.submit(task);  
TimeUnit.SECONDS.sleep(2);  
InterruptableTask theTask = tasks.get(1);//get task by id
theTask.suspend();  
TimeUnit.SECONDS.sleep(2);  
theTask.resume();  
TimeUnit.SECONDS.sleep(4);                
threadPool.shutdownNow();      
}
```
- Pouvez-vous être plus précis et de m'offrir une réelle mise en œuvre ou un exemple? J'ai vraiment apprécié, parce que je suis aux prises avec ce problème un temps assez long.
- pourquoi ne pas vous rendre vos tâches annulable?Ce n'est pas une bonne idée d'interagir avec les fils de votre code n'est pas propre directement
- Je suis d'accord avec la recommandation de faire des tâches annulable. L'OP a écrit: "imaginez que je veux arrêter le thread id=0". Cela ne fait pas beaucoup de sens, parce qu'à un moment donné vous ne savez pas ce thread 0 est en train de faire. Mais il est logique de parler de l'arrêt de certains travaux en cours, d'où la recommandation à propos de l'annulation de tâches.
- En fait mon fils sont à l'aide d'un drapeau à être annulées. Sur mon tout itération de boucle j'utilise le drapeau jusqu'à ce que je l'ai mis à false. Donc oui, mon Runnables sont cancellables. Le problème est que, si j'ai mis le drapeau de faux et arrêter l'exécution, en inspectant les fils d'état, je peux voir que mon fils est un état d'attente. Ce qui est cool en quelque sorte. Maintenant, le problème que je vais avoir est de savoir comment reprendre le cours de leur travail? Et merci de ne pas répondre à "réglage de l'indicateur à l'état précédent" parce que cela ne fonctionne pas
- exemple de code
- ressemble exactement à ce que je cherchais, à l'exception d'une seule partie. Vous êtes à la notification de tous les threads qui signifie que si j'ai 2 tâches en pause (id=1, et id=2) et que vous souhaitez reprendre la tâche avec l'id=2, vous êtes à la notification de tous les threads (id=1 et id=2). Suis-je la corriger?
- thread va exécuter sur son propre InterruptableTask et puisqu'elles ne sont pas partagées, la lock est privé pour chaque thread
- dire o agissant comme un lock n'est pas partagé entre les threads
- seul écueil, c'est que si vous laissez un thread suspended et puis essayez d'arrêter l'application, la JVM ne sera pas de l'arrêt sice, le thread est bloqué dans wait.Vous devez faire les fils deamons, ou de mettre en œuvre ce que vous avez vraiment besoin attentivement
- une question de plus. Sur l'instruction else pourquoi utilisez-vous qu'en suspension drapeau? L'o.wait() de ce que j'ai vu est le blocage de la sorte, je pense que vous n'en avez pas besoin. J'ai fait quelques tests avec la mise en place et tout fonctionne bien, même sans que tout. Donc, je pense que je peux fermer cette question et votre réponse comme la meilleure, ou du moins celle qui correspond à mes besoins. Encore une fois merci. Mise À Jour: Oui. J'ai vu ça! J'essaie de laisser un thread en mode de suspension et d'appeler à l'arrêt et de la JVM a été laissé en marche. J'ai repéré ce problème ainsi.
- toujours faire appel à wait à l'intérieur d'un while boucle pour éviter des réveils docs.oracle.com/javase/6/docs/api/java/lang/Object.html#wait()
- Merci pour les conseils. J'ai remarqué que si vous appelez threadPool.shutdownNow(); tous les threads qui sont dans wait() sera interrompu. Alors pourquoi ne pas la JVM arrête l'exécution de l'appel de shutdownNow()?
- ferme le pool de threads douceur, en laissant en cours d'exécution des tâches à exécuter et les tâches en cours sont autorisés à remplir. shutdownNow annule tout (de retour d'une listes de toutes les tâches non commencé) et s'arrête brusquement
InformationsquelleAutor Cratylus
4

Suggestion: de la Même manière à/au lieu des indicateurs que vous utilisez, de créer un sémaphore avec 1 de permis (new Semaphore(1)) pour chaque tâche, vous avez besoin pour mettre en pause/reprendre. Au début de la tâche de travail du cycle de mettre un code comme ceci:
```
semaphore.acquire();
semaphore.release();
```
Cela provoque la tâche d'acquérir un sémaphore de permis et de les libérer immédiatement et sans elle. Maintenant, si vous souhaitez interrompre le fil (un bouton est enfoncé, par exemple), appel semaphore.acquire() partir d'un autre thread. Depuis le sémaphore a 0 permis de maintenant, votre thread de travail sera en pause au début du cycle suivant et attendre jusqu'à ce que vous appelez semaphore.release() de l'autre thread.

(Le acquire() méthode renvoie InterruptedException, si votre thread de travail est interrompu pendant l'attente. Il existe une autre méthode acquireUninterruptibly(), qui tente également d'obtenir un permis, mais ne doit pas être interrompue.)
- Bien sûr, il ne le travail, mais ressemble plus à un hack et c'est une meilleure approche que de ne rien faire. Donc merci de répondre. Je vais tester votre approche et @user384706 et de voir celui qui a une meilleure performance.
InformationsquelleAutor Petr Pudlák

Vous devez vous connecter pour publier un commentaire.