Callable接口

创建线程的方法

一种是通过创建Thread类，另一种是通过使用Runnable创建线程。但是，Runnable缺少的一项功能是，当线程终止时（即run（）完成时），我们无法使线程返回结果。为了支持此功能，Java中提供了Callable接口。当然了还可以使用线程池创建线程。
Callable接口和Runnable接口的区别
• 为了实现Runnable，需要实现不返回任何内容的run（）方法，而对于Callable，需要实现在完成时返回结果的call（）方法。
• call（）方法可以引发异常，而run（）则不能。
• 为实现Callable而必须重写call方法
• 不能直接替换runnable,因为Thread类的构造方法根本没有Callable

Future接口

当call（）方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用Future对象。
将Future视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦Callable返回）。Future基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。要实现此接口，必须重写5种方法，这里列出了重要的方法,如下:
• public boolean cancel（boolean mayInterrupt）：用于停止任务。
如果尚未启动，它将停止任务。如果已启动，则仅在mayInterrupt为true时才会中断任务。
• public Object get（）抛出InterruptedException，ExecutionException：用于获取任务的结果。
如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。
• public boolean isDone（）：如果任务完成，则返回true，否则返回false
可以看到Callable和Future做两件事-Callable与Runnable类似，因为它封装了要在另一个线程上运行的任务，而Future用于存储从另一个线程获得的结果。实际上，future也可以与Runnable一起使用。
要创建线程，需要Runnable。为了获得结果，需要future。

FutureTask

Java库具有具体的FutureTask类型，该类型实现Runnable和Future，并方便地将两种功能组合在一起。可以通过为其构造函数提供Callable来创建FutureTask。然后，将FutureTask对象提供给Thread的构造函数以创建Thread对象。因此，间接地使用Callable创建线程。

核心原理:(重点)

在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给Future对象在后台完成
• 当主线程将来需要时，就可以通过Future对象获得后台作业的计算结果或者执行状态
一般FutureTask多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。
• 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法
• 一旦计算完成，就不能再重新开始或取消计算
• get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常
• get只计算一次,因此get方法放到最后

Callable创建线程

package com.dongguo;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/** * @author Dongguo * @date 2021/8/24 0024-15:24 * @description: */
public class threadDemo1 { 
    public static void main(String[] args) { 
        //Runnable接口创建线程
        new Thread(new MyThread(), "ThreadA").start();
        //Callable接口创建线程
        FutureTask<Integer> task1 = new FutureTask<>(new MyThread2());
        new Thread(task1, "ThreadB").start();
        //lambda表达式实现
        FutureTask<Integer> task2 = new FutureTask<>(() -> { 
            System.out.println(Thread.currentThread().getName() + "使用callable");
            return 20;
        });
        //创建一个线程
        new Thread(task2, "ThreadC").start();
        try { 
            System.out.println(task2.get());
        } catch (InterruptedException e) { 
            e.printStackTrace();
        } catch (ExecutionException e) { 
            e.printStackTrace();
        }
    }
}
//创建新类MyThread实现runnable接口
class MyThread implements Runnable { 
    @Override
    public void run() { 
    }
}
//新类MyThread2实现callable接口
class MyThread2 implements Callable<Integer> { 
    @Override
    public Integer call() throws Exception { 
        return 200;
    }
}
运行结果：
ThreadC使用callable
20

isDone()

package com.dongguo;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/** * @author Dongguo * @date 2021/8/24 0024-15:24 * @description: */
public class threadDemo1 { 
    public static void main(String[] args) { 
        //Runnable接口创建线程
        new Thread(new MyThread(), "ThreadA").start();
        //Callable接口创建线程
        FutureTask<Integer> task1 = new FutureTask<>(new MyThread2());
        new Thread(task1, "ThreadB").start();
        //lambda表达式实现
        FutureTask<Integer> task2 = new FutureTask<>(() -> { 
            System.out.println(Thread.currentThread().getName() + "使用callable");
            return 20;
        });
        //创建一个线程
        new Thread(task2, "ThreadC").start();
        //是否完成 如果未完成
        while (!task2.isDone()){ 
            System.out.println(Thread.currentThread().getName() + "未完成");
        }
        try { 
            System.out.println(task2.get());
        } catch (InterruptedException e) { 
            e.printStackTrace();
        } catch (ExecutionException e) { 
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "完成");
    }
}
//创建新类MyThread实现runnable接口
class MyThread implements Runnable { 
    @Override
    public void run() { 
    }
}
//新类MyThread2实现callable接口
class MyThread2 implements Callable<Integer> { 
    @Override
    public Integer call() throws Exception { 
        return 200;
    }
}

在这里插入图片描述
多次调用get()

package com.dongguo;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/** * @author Dongguo * @date 2021/8/24 0024-15:24 * @description: */
public class threadDemo1 { 
    public static void main(String[] args) { 
        //Runnable接口创建线程
        new Thread(new MyThread(), "ThreadA").start();
        //Callable接口创建线程
        FutureTask<Integer> task1 = new FutureTask<>(new MyThread2());
        new Thread(task1, "ThreadB").start();
        //lambda表达式实现
        FutureTask<Integer> task2 = new FutureTask<>(() -> { 
            System.out.println(Thread.currentThread().getName() + "使用callable");
            return 20;
        });
        //创建一个线程
        new Thread(task2, "ThreadC").start();
        //是否完成 如果未完成
        while (!task2.isDone()){ 
            System.out.println(Thread.currentThread().getName() + "未完成");
        }
        try { 
            //可以多次get获得返回值
            System.out.println(task2.get());
            System.out.println(task2.get());
            System.out.println(task2.get());
        } catch (InterruptedException e) { 
            e.printStackTrace();
        } catch (ExecutionException e) { 
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "完成");
    }
}
//创建新类MyThread实现runnable接口
class MyThread implements Runnable { 
    @Override
    public void run() { 
    }
}
//新类MyThread2实现callable接口
class MyThread2 implements Callable<Integer> { 
    @Override
    public Integer call() throws Exception { 
        return 200;
    }
}

在这里插入图片描述
创建两个线程先执行task2再执行task1

package com.dongguo;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/** * @author Dongguo * @date 2021/8/24 0024-15:24 * @description: */
public class threadDemo1 { 
    public static void main(String[] args) { 
        //Runnable接口创建线程
        new Thread(new MyThread(), "ThreadA").start();
        //Callable接口创建线程
        FutureTask<Integer> task1 = new FutureTask<>(new MyThread2());
        //lambda表达式实现
        FutureTask<Integer> task2 = new FutureTask<>(() -> { 
            System.out.println(Thread.currentThread().getName() + "使用callable");
            return 20;
        });
        //创建一个线程
        new Thread(task2, "ThreadC").start();
        new Thread(task1, "ThreadB").start();
        try { 
            //可以多次get获得返回值
            System.out.println(task1.get());
            System.out.println(task2.get());
        } catch (InterruptedException e) { 
            e.printStackTrace();
        } catch (ExecutionException e) { 
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "完成");
    }
}
//创建新类MyThread实现runnable接口
class MyThread implements Runnable { 
    @Override
    public void run() { 
    }
}
//新类MyThread2实现callable接口
class MyThread2 implements Callable<Integer> { 
    @Override
    public Integer call() throws Exception { 
        System.out.println(Thread.currentThread().getName() + "使用callable");
        return 200;
    }
}
运行结果:
ThreadC使用callable
ThreadB使用callable
200
20
main完成

总结

• 在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给Future对象在后台完成, 当主线程将来需要时，就可以通过Future对象获得后台作业的计算结果或者执行状态
• 一般FutureTask多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果
• 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。