The Callable interface of the third way of JAVA high concurrency (JUC) to create threads

We naturally know the three ways to create threads. I won't talk about the first two. This time we are talking about the third Callable interface.
First, let's compare the difference between Runnable interface and Callable interface:

//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;
    }
}

We can see that Callable has generics and return values. This is an enhancement to the original old technology. Because of the return value, the fine-grained thread is improved.

Then we look at the way to create threads:

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

But in this way, we use Callable to create a thread, but an error is reported. Why?

Reason: Thread does not have a Callable constructor!

So how do we create threads? ?
First look at the API, look at the Runable interface:


click on its implementation class and
look at its construction method: the

process is as follows:

what we can see is that the parameters required by this constructor are the implementation classes of the Callable interface.
So, the way we create threads is as follows:

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方法来获取返回值
    }
}

Here we look at some details:
Detail one:

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;
    }
}

Then switch to the 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;
    }
}

So we can know that the get method has a blocking effect.
Detail 2:
Add a new thread 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;
    }
}

Print result:

only executed once, because a futureTask, no matter how many threads are called, all call the same futureTask object! And the Runnable interface is different:

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");
    }
}

The above is the way to create threads by implementing the Callable interface.