1. Concept
Future représente le résultat d'une tâche asynchrone qui n'a peut-être pas été terminée. Un rappel peut être ajouté à ce résultat pour effectuer les opérations correspondantes après la réussite ou l'échec de l'exécution de la tâche.
2. Future interface
L'interface Future définit cinq méthodes d'interface principales RunnableFuture et ScheduleFuture héritent de cette interface, et CompleteFuture et ForkJoinTask héritent de cette interface.
3. Exemples
test de paquet ;
importer java.util.concurrent.Callable ;
importer java.util.concurrent.ExecutionException ;
importer java.util.concurrent.FutureTask ;
classe publique CallableFutureTest {
public static void main (String[] arguments) {
long startTime = System.currentTimeMillis();
Callable<Integer> calculateCallable = new Callable<Integer>() {
@Outrepasser
public Integer call() lève une exception {
// TODO Stub de méthode généré automatiquement
Thread.sleep(2000); //Résultat int long de simulation = 1+2;
renvoyer le résultat ;
}
} ;
FutureTask<Integer> calculateFutureTask = new FutureTask<>(calculateCallable);
Thread t1 = nouveau Thread (calculateFutureTask);
t1.start();
//Rejoignez maintenant Thread pour exécuter un service chronophage qui simule les appels à distance et s'appuie sur ses résultats de calcul (comme une calculatrice réseau)
essayer {
// Simulez des tâches fastidieuses, le thread principal fait son propre travail, reflétant les avantages du multithreading Thread.sleep(3000);
int a = 3+5 ;
Résultat entier = calculateFutureTask.get();
System.out.println("result = "+(a+result));//Simuler le résultat d'exécution du thread principal en s'appuyant sur le sous-thread long endTime = System.currentTimeMillis();
System.out.println("time = "+(endTime-startTime)+"ms");
} catch (InterruptedException | ExecutionException e) {
// TODO Bloc catch généré automatiquement
e.printStackTrace();
}
}
} Comme vous pouvez le voir ci-dessus, le temps pris ci-dessus est d'environ 3 secondes. En fait, c'est principalement le temps passé par le thread principal sleep(3000). Si nous n'utilisons pas Future et nous basons sur les résultats du thread, le. le temps dont nous pourrions avoir besoin peut être de 5 s (sous-thread 2 s + thread principal 3 s).
Ce qui précède montre comment Future obtient les résultats des threads en Java. On peut dire que Future est plus flexible dans le traitement des threads. Le mécanisme est à peu près le suivant: lorsqu'un thread est en cours d'exécution, un autre thread s'exécute en même temps. Si vous êtes intéressé, vous pourrez en apprendre davantage après le cours.