L'interface appelable de la troisième manière de JAVA haute concurrence (JUC) pour créer des threads

Nous connaissons naturellement les trois façons de créer des threads, je ne dirai pas grand-chose des deux premières, cette fois, nous parlons de la troisième interface Callable .
Tout d'abord, comparons la différence entre l'interface Runnable et l'interface Callable:

//Runnable接口
class MyThreadRunnable implements Runnable {

    @Override
    public void run() {
      
    }
}

//Callable
class MyThreadCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("******come in here");
        return 1024;
    }
}

Nous pouvons voir que Callable a des génériques et des valeurs de retour. Il s'agit d'une amélioration de l'ancienne technologie d'origine. En raison de la valeur de retour, le thread fin est amélioré.

Ensuite, nous examinons la façon de créer des threads:

        //Runnable
        MyThreadRunnable myThread1=new MyThreadRunnable();
        Thread t1=new Thread(myThread1);

Mais de cette manière, nous utilisons Callable pour créer un thread, mais une erreur est signalée.

Raison: Thread n'a pas de constructeur appelable!

Alors, comment créons-nous des fils? ?
Regardez d'abord l'API, regardez l'interface Runable:


cliquez sur sa classe d'implémentation et
regardez sa méthode de construction: le

processus est le suivant:

ce que nous pouvons voir, c'est que les paramètres requis par ce constructeur sont les classes d'implémentation de l'interface Callable.
Ainsi, la façon dont nous créons des threads est la suivante:

public class CallableDemo {
    public static void main(String[] args) {
//        MyThreadCallable myThread = new MyThreadCallable();
        FutureTask futureTask = new FutureTask(new MyThreadCallable());
        new Thread(futureTask, "A").start();
        System.out.println(futureTask.get());// 1024  通过get方法来获取返回值
    }
}

Nous examinons ici quelques détails:
Détail un:

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        MyThreadCallable myThread = new MyThreadCallable();
        FutureTask futureTask = new FutureTask(new MyThreadCallable());
        new Thread(futureTask, "A").start();
        System.out.println(futureTask.get());// 1024  通过get方式来获取返回值  该方法会阻塞！
        System.out.println(Thread.currentThread().getName()+"***计算完成");
    }
}
//Callable
class MyThreadCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("******come in here");
        Thread.sleep(5000);
        return 1024;
    }
}

Puis passez à la position

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        MyThreadCallable myThread = new MyThreadCallable();
        FutureTask futureTask = new FutureTask(new MyThreadCallable());
        new Thread(futureTask, "A").start();
         System.out.println(Thread.currentThread().getName()+"***计算完成");
        System.out.println(futureTask.get());// 1024  通过get方式来获取返回值  该方法会阻塞！
    }
}
//Callable
class MyThreadCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("******come in here");
        Thread.sleep(5000);
        return 1024;
    }
}

Nous pouvons donc savoir que la méthode get a un effet bloquant.
Détail 2:
Ajouter un nouveau fil B:

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        MyThreadCallable myThread = new MyThreadCallable();
        FutureTask futureTask = new FutureTask(new MyThreadCallable());
        new Thread(futureTask, "A").start();
        new Thread(futureTask, "B").start();
        System.out.println(Thread.currentThread().getName() + "***计算完成");
        System.out.println(futureTask.get());// 1024  通过get方式来获取返回值  该方法会阻塞！
    }
}

//Callable
class MyThreadCallable implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("******come in here");
        Thread.sleep(5000);
        return 1024;
    }
}

Résultat d'impression:

exécuté une seule fois, car une futureTask, quel que soit le nombre de threads appelés, appelle tous le même objet futureTask! Et l'interface Runnable est différente:

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThreadRunnable t = new MyThreadRunnable();
        Thread thread = new Thread(t);
        new Thread(thread).run();
        new Thread(thread).run();
    }
}

//Runnable接口
class MyThreadRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("******come in here");
    }
}

Ce qui précède est le moyen de créer des threads en implémentant l'interface Callable.