1、可以有返回值；
2、可以抛出异常；
3、方法不同，run()/call()
代码测试
传统使用线程方式：
public class CallableTest {
public static void main(String[] args) {
for (int i = 1; i < 10; i++) {
new Thread(new MyThread()).start();
}
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
使用Callable进行多线程操作：
package demo925;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
myThread thread=new myThread();//怎么启动callable
FutureTask futureTask = new FutureTask(thread);//适配类
new Thread(futureTask,"a").start();
Integer o =(Integer) futureTask.get();//获取callable的返回结果
System.out.println(o);
}
static class myThread implements Callable{
@Override
public Integer call() throws Exception {
System.out.println("call");
return 1024;
}
}
}
Calleable 泛型T就是call运行方法的返回值类型；
但是如何使用呢？
Callable怎么放入到Thread里面呢？
对于Thread运行，只能传入Runnable类型的参数；
我们这是Callable 怎么办呢？
看JDK api文档：
在Runnable里面有一个叫做FutureTask的实现类，我们进去看一下。
这样我们就可以先把Callable 放入到FutureTask中， 如何再把FutureTask 放入到Thread就可以了。
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
for (int i = 1; i < 10; i++) {
// new Thread(new Runnable()).start();
// new Thread(new FutureTask<>( Callable)).start();
MyThread thread= new MyThread();
//适配类：FutureTask
FutureTask futureTask = new FutureTask<>(thread);
//放入Thread使用
new Thread(futureTask,String.valueOf(i)).start();
//获取返回值
String s = futureTask.get();
System.out.println("返回值："+ s);
}
}
}
class MyThread implements Callable {
@Override
public String call() throws Exception {
System.out.println("Call:"+Thread.currentThread().getName());
return "String"+Thread.currentThread().getName();
}
}
这样我们就可以使用Callable来进行多线程编程了，并且我们发现可以有返回值，并且可以抛出异常。
