La copie de code est la suivante:
Package com.yao;
import java.util.concurrent.Callable;
Importer java.util.concurrent.executionException;
Importer java.util.concurrent.executorService;
Importer java.util.concurrent.executors;
import java.util.concurrent.future;
Importer java.util.concurrent.scheduleDExecutorService;
Importer java.util.concurrent.TimeUnit;
/ **
* New Task Exécution Architecture.
* Avant Java 5.0, une tâche a été lancée par l'appel de la méthode start () de la classe de threads.
* La soumission et l'exécution des tâches sont effectuées simultanément.
* Ou contrôler le nombre de threads exécutés simultanément nécessite un code supplémentaire.
* 5.0 fournit une nouvelle architecture d'exécution de tâches qui vous permet de planifier et de contrôler facilement l'exécution des tâches.
* Et un pool de threads similaire à un pool de connexions de base de données peut être établi pour effectuer des tâches.
* Cette architecture se compose principalement de trois interfaces et de leurs classes spécifiques correspondantes.
* Ces trois interfaces sont exécutrice, exécutrice exécutoire et planification de divulgation.
* (1) Interface exécuteur: est utilisé pour exécuter des tâches exécutables, il définit une seule méthode:
* EXECUTER (Commande Runnable): Exécuter des tâches de type ruannable
* (2) ExecutorService: hérite de la méthode de l'exécuteur et fournit des services pour exécuter des tâches callables et abandonner l'exécution des tâches.
* Les principales méthodes de sa définition sont:
* Soumettre (tâche): peut être utilisé pour soumettre des tâches callables ou exécutables et renvoyer le futur objet représentant cette tâche
* InvokeALL (collection de tâches): collection de tâches de lots et renvoyez une collection d'objets futurs représentant ces tâches.
* shutdown (): fermez le service après avoir terminé la tâche soumise et n'accepte plus de nouvelles tâches.
* shutdownnow (): arrête toutes les tâches d'exécution et ferme le service.
* Isterminé (): Testez si toutes les tâches ont été exécutées.
* iSShutdown (): Testez si le service exécutif a été fermé
* (3) ScheduleDExECUTORSERVICE: Hérite d'exécution, offrant la fonction des tâches de planification en fonction du temps,
* Calendrier (tâche, initdelay): Planifiez la tâche callable ou exécutable soumise à exécuter après l'heure spécifiée par initdelay.
* scheduleAtFixeDrate (): Planifiez la tâche exécutable soumise à exécuter à plusieurs reprises à l'intervalle spécifié.
* schedulewithfixeddelay (): Planifiez la tâche exécutable soumise à exécuter à plusieurs reprises après chaque exécution, attendez le temps spécifié par retard.
*
* Obtenez divers objets de service via la classe des exécuteurs.
* Callable (tâche Runnable): convertir les tâches de course en tâches appelant
* NewsingLeThreAdExECUTOR: génère un objet ExecutorService, qui n'a qu'un seul thread qui peut être utilisé pour exécuter des tâches.
* NewCachedThreadPool (): génère un objet ExecutorService, qui a un pool de threads.
* NewFixEdThreadPool (int poolsize): génère un objet ExecutorService, qui a un pool de fil de taille de poassage.
* NewsingLeThReadScheduleDexecutor: Génère un objet ScheduleDexecutorService, la taille du pool de threads de cet objet est 1. S'il y a plus d'une tâche, les tâches seront exécutées en séquence.
* NewsCheDuledThreadPool (int poolsize): génère un objet ScheduleDexeCutorService, la taille du pool de threads de cet objet est de la révision.
* /
classe publique Executearch {
/ **
* Ce thread sort une chaîne
* /
classe statique publique Mythread implémente Runnable {
public void run () {
System.out.println ("Tâche répéter." + System.Currenttimemillis ());
essayer {
Thread.Sleep (1000);
} catch (InterruptedException e) {
System.out.println («Tâche interrompue».
+ System.Currenttimemillis ());
}
}
}
/ **
* Le callable met fin à une autre tâche
* /
classe statique publique MyCallable implémente callable {
avenir avenir privé;
public mycallable (futur futur) {
this.future = futur;
}
Call de chaîne publique () {
System.out.println ("Pour annuler la tâche ..."
+ + System.Currenttimemillis ());
this.future.cancel (true);
Renvoie "Tâche annulée!";
}
}
/ **
* @param args
* @Throws ExecutionException
* @Throws InterruptedException
* /
public static void Main (String [] args) lève l'interruption
EXECUTUTIONException {
// Générez un objet ExecutorService, qui a un pool de threads, et la taille du pool de threads sera ajustée au besoin.
// Une fois que le thread a exécuté la tâche, il revient au pool de threads pour que la tâche suivante soit utilisée.
ExecutorService cachedService = exécutors.newcachedThreadPool ();
Future MyThreadFuture = CachedService.Submit (new MyThread ());
Futur mycallablefuture = cachedService.soubmit (new mycallable (
mythreadfuture));
System.out.println (myCallableFuture.get ());
System.out.println ("-----------------");
// convertir les tâches coulables en tâches appelant
Callable MyThreadCallable = EMICRORS.CALLABLE (new MyThread ());
Futur myThreadCallableFuture = cachedService.SUMMIT (myThreadCallable);
// Pour les tâches coulables, aucune valeur n'est renvoyée après avoir été convertie en tâches appelables
System.out.println (myThreadCallableFuture.get ());
cachedService.shutdownNow ();
System.out.println ("-----------------");
// Générez un objet ExecutorService, qui a un pool de fil de taille de poolSize.
// Si le nombre de tâches est supérieur à PoolSize, les tâches seront exécutées dans une file d'attente en séquence
ExecutorService fixeService = exécutor.NewFixEdThreadPool (2);
fixeService.Submit (new Mythread ());
fixeService.Submit (new Mythread ());
// Étant donné que la taille du pool de thread est de 2, les tâches suivantes doivent attendre que les tâches précédentes soient exécutées avant de pouvoir être exécutées.
myThreadFuture = fixeService.SUMMit (new MyThread ());
myCallableFuture = fixeService.Submit (new myCallable (mythreadfuture));
System.out.println (myCallableFuture.get ());
fixeService.shutdownNow ();
System.out.println ("-----------------");
// Générez un objet ScheduleDExecutorService, la taille du pool de threads de cet objet est de la taille de pool.
// Si le nombre de tâches est supérieur à PoolSize, la tâche attendra l'exécution dans une file d'attente
ScheduleDExECUTORSERVICE FIXTSCHEDULEDSERVICE = Exécuteurs
.NewScheduledThreadpool (2);
// Créer une nouvelle tâche 1
Mythread Task1 = new Mythread ();
// Utilisez le service d'exécution de la tâche pour exécuter immédiatement la tâche 1, puis exécutez la tâche 1 toutes les 2 secondes par la suite.
myThreadFuture = fixeScheduledService.ScheduleAtFixeDrate (Task1, 0, 2,
TimeUnit.seconds);
// Créer une nouvelle tâche 2
Tâche mycallable2 = new myCallable (mythreadfuture);
// Utilisez le service d'exécution des tâches pour attendre 5 secondes avant d'exécuter la tâche 2. Après l'exécution, la tâche 1 sera fermée.
MyCallableFuture = FixTScheduledService.Schedule (Task2, 5,
TimeUnit.seconds);
System.out.println (myCallableFuture.get ());
fixeScheduledService.shutdownNow ();
}
}