java-concurrency-Callable, Future et FutureTask

Il existe deux façons de créer un thread, l'une consiste à hériter directement de Thread et l'autre à implémenter l'interface Runnable

Différence : l'interface peut implémenter l'héritage multiple

Le défaut est : après l'exécution de la tâche Les résultats de l'exécution ne peuvent pas être obtenus par la suite

Callable and Runnable

java.lang.Runnable

[code]public interface Runnable {
    public abstract void run();
}

Depuis la valeur de retour du run( ) est de type void, la tâche ne sera pas exécutée après le Aucun résultat ne pourra être renvoyé par la suite.

java.util.concurren

[code]public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

Interface générique, le type renvoyé par la fonction call() est le type V passé dans

Généralement, il est utilisé dans conjointement avec ExecutorService Used, plusieurs versions surchargées de la méthode submit sont déclarées dans l'interface ExecutorService

[code]<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

Future

Future consiste à annuler et à interroger les résultats d'exécution de tâches spécifiques Runnable ou Callable. Complétez et obtenez des résultats. Si nécessaire, vous pouvez obtenir le résultat de l'exécution via la méthode get. Cette méthode se bloquera jusqu'à ce que la tâche renvoie le résultat

[code]public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

La méthode Cancel est utilisée pour annuler la tâche si l'annulation de la tâche réussit. , il renvoie true. Si l'annulation de la tâche échoue, il renvoie false. Le paramètre mayInterruptIfRunning indique s'il est autorisé à annuler les tâches en cours d'exécution mais qui ne sont pas terminées. S'il est défini sur true, cela signifie que les tâches en cours d'exécution peuvent être annulées. Si la tâche est terminée, que mayInterruptIfRunning soit vrai ou faux, cette méthode renverra certainement false, c'est-à-dire que si la tâche terminée est annulée, elle renverra false si la tâche est en cours d'exécution, si mayInterruptIfRunning est défini sur true ; il retournera true, si mayInterruptIfRunning est défini sur false , puis retournera false ; si la tâche n'a pas été exécutée, alors que mayInterruptIfRunning soit true ou false, elle retournera certainement true.

La méthode isCancelled indique si la tâche est annulée avec succès. Si la tâche est annulée avec succès avant qu'elle ne soit terminée normalement, elle renvoie true. La méthode

isDone indique si la tâche est terminée. Si la tâche est terminée, elle renvoie true ;

la méthode get() est utilisée pour obtenir le résultat de l'exécution. attendra que la tâche soit terminée. avant de revenir ;

get(long timeout, TimeUnit unit) est utilisé pour obtenir le résultat de l'exécution. Si le résultat n'est pas obtenu dans le délai spécifié, null sera renvoyé directement.

C'est-à-dire que Future propose trois fonctions :

1) Déterminer si la tâche est terminée

2) Capable d'interrompre la tâche
<🎜 ; > 3) Capable d'obtenir les résultats de l'exécution des tâches.

Parce que Future n'est qu'une interface, elle ne peut pas être utilisée directement pour créer des objets, il y a donc la FutureTask suivante.

FutureTask

[code]public class FutureTask<V> implements RunnableFuture<V>

[code]public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

[code]public FutureTask(Callable<V> callable) {
}
public FutureTask(Runnable runnable, V result) {
}

En fait, FutureTask est la seule classe d'implémentation de l'interface Future.

Exemple

[code]public class Test {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<Integer> result = executor.submit(task);
        executor.shutdown();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        System.out.println("主线程在执行任务");

        try {
            System.out.println("task运行结果"+result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务执行完毕");
    }
}
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}

[code]public class Test {
    public static void main(String[] args) {
        //第一种方式
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        executor.submit(futureTask);
        executor.shutdown();

        //第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread
        /*Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        Thread thread = new Thread(futureTask);
        thread.start();*/

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        System.out.println("主线程在执行任务");

        try {
            System.out.println("task运行结果"+futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("所有任务执行完毕");
    }
}
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("子线程在进行计算");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}

Si vous utilisez Future pour l'annulation mais ne fournissez pas de résultats utilisables, vous pouvez déclarer Future

Ce qui précède est java- Contenu Concurrency-Callable, Future et FutureTask, veuillez faire attention au site Web PHP chinois (www.php.cn) pour plus de contenu connexe !