[Multithreading Java] Créez la troisième méthode de multithreading : implémentez l'interface Callable

L'implémentation de l'interface Callable est une nouvelle méthode de création de threads dans JDK5.0

Callable est plus puissant que Runnable

1. Par rapport à la méthode run(), il peut y avoir une valeur de retour

2. La méthode peut lever une exception

3. Prise en charge de la valeur de retour générique

4. Vous devez utiliser la classe FutureTask, par exemple pour obtenir le résultat renvoyé

Interface future

1. Vous pouvez annuler les résultats d'exécution de tâches exécutables et appelables spécifiques, demander si elles sont terminées, obtenir des résultats, etc.

2.FutrueTask est la seule classe d'implémentation de l'interface Futrue

3.FutureTask implémente les interfaces Runnable et Future en même temps. Il peut être exécuté par un thread en tant que Runnable, et peut également être utilisé en tant que Future pour obtenir la valeur de retour de Callable

================================================= =======================

Étapes pour implémenter l'interface Callable pour créer plusieurs threads :

1. Créez une classe d'implémentation qui implémente Callable
2. Implémentez la méthode call et déclarez les opérations que ce thread doit effectuer dans call()
3. Créez un objet de la classe d'implémentation d'interface Callable
4. Passez l'objet de la classe d'implémentation d'interface Callable au constructeur FutureTask pour créer un objet FutureTask
5. Transmettez l'objet FutureTask en tant que paramètre au constructeur de la classe Thread, créez un objet Thread et appelez start()
6. Obtenez la valeur de retour de la méthode d'appel dans Callable

================================================= =======================

Prenez "parcourir les nombres pairs entre 1 et 100 et renvoyer la somme de tous les nombres pairs" comme exemple

Le code ressemble à ceci ;

//1.创建一个实现Callable的实现类
class NumThread implements Callable{

    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();

        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);

        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写call()的返回值
            Object sum = futureTask.get();
            System.out.println("总合：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

================================================= =======================

Comment comprendre que l'implémentation de l'interface Callable pour créer plusieurs threads est plus puissante que l'implémentation de l'interface Runnable pour créer plusieurs threads ?
* 1.call() peut avoir une valeur de retour
* 2. call() peut lancer une exception, qui peut être interceptée par des opérations externes et obtenir des informations sur l'exception
* 3. Callable prend en charge les génériques (j'expliquerai ce que sont les génériques dans de futurs articles)

Merci d'avoir regardé! ! !