Callable实现多线程

从Java提供多线程开始，最初的方案就是依靠Runnable接口定义线程类核心功能，但是Runnable中的run方法有一个缺点：该方法没有返回值。从JDK1.5开始，在JUC（java.util.concurrent）包中提供了一个新的多线程实现接口：

@FunctionalInterface
public interface Callable<V>{
    public V call() throws Exception;
}

接口Callable中有一个call方法，其返回值类型为V，这是一个泛型。值得关注的是这个call方法有返回值，这意味着线程执行完毕后可以将处理结果返回。

根据以往的套路，我们要创建一个实现Callable的的类，将其作为线程主体，这个类要覆写call方法（其实call方法和run方法类似）：

class MyThread4 implements Callable<String>{ // 定义核心业务类
	private String name;
	
	public MyThread4(String name) {
		this.name = name;
	}
	
	@Override
	public String call() throws Exception {
		for(int i = 0 ; i < 100; i++) {
			System.out.println(this.name + "线程运行， x = " + i);
		}
		return "执行完毕";  // 返回值
	}
}

定义好了相应的线程执行类，就要用Thread的start()方法启动线程，但是表面上看Callable和Thread并没有联系，这需要我们深入的挖掘源码：

 

1、我们先从Java API中的java.util.concurrent包内找到Future<V>

public interface Future<V>{
    V get() throws InterruptedException, ExecutionException;
}

可以发现接口Future中有一个get()方法，注意：这个get()方法可以获取callable方法的返回值。那现在我们可以获取Callable的返回值，但是，依旧看不出和Thread的关系。

 

2、再回到java.util.concurrent包中，找到RunnableFuture<V>

public interface RunnableFuture<V>
extends Runnable, Future<V>{
    void run();
}

这里我们先不关注run()方法，注意接口RunnableFuture继承了接口Runnable和接口Future<V>。

 

3、查看Runnable的实现类，发现了FutureTask<V>，FutureTask<V>有两个构造方法，我们关注其中一个：

public FutureTask(Callable<V> callable)

这个构造方法可传callable的实现类，而FutureTask又继承了Runnable。

所以Callable传给FutureTask，FutureTask又继承了Runnable，FutureTask就能作为Runnable传给Thread，start()方法就得以调用。

Callable与Runnable两个多线程接口最大的差别在于Callable有返回值。实际使用哪个要看具体的需求。

 

完整代码：

class MyThread4 implements Callable<String>{ // 定义核心业务类
	private String name;
	
	public MyThread4(String name) {
		this.name = name;
	}
	
	@Override
	public String call() throws Exception {
		for(int i = 0 ; i < 100; i++) {
			System.out.println(this.name + "线程运行， x = " + i);
		}
		return "执行完毕";  // 返回值
	}
}

public class CallableTest {

	public static void main(String[] args) throws Exception{
		
		Callable<String> callA = new MyThread4("线程A");
		Callable<String> callB = new MyThread4("线程B");
		Callable<String> callC = new MyThread4("线程C");
		
		FutureTask<String> futureA = new FutureTask<String>(callA);
		FutureTask<String> futureB = new FutureTask<String>(callB);
		FutureTask<String> futureC = new FutureTask<String>(callC);
		
		new Thread(futureA).start();
		new Thread(futureB).start();
		new Thread(futureC).start();
		
		System.out.println("A执行返回结果："  + futureA.get());
		System.out.println("B执行返回结果："  + futureB.get());
		System.out.println("C执行返回结果："  + futureC.get());
	}

}