有返回值的多线程的实现：FutureTask+Callable

FutureTask类是Future 的一个实现，并实现了Runnable，所以可通过Excutor(线程池) 来执行,也可传递给Thread对象执行。

1 FutureTask类实现了RunnableFuture接口
public class FutureTask<V> implements RunnableFuture<V>
 　　
2 public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值

Callable接口则提供了一种有返回值的多线程实现方法，callable接口执行完成后FutureTask回调done（）方法，同时FutureTask可以通过get()方法获得callable接口的返回值。

package com.java.test.futuretask;

/**
 * 我们先来看一下FutureTask的实现：

1 FutureTask类实现了RunnableFuture接口
	public class FutureTask<V> implements RunnableFuture<V>
 　　
2
public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

	可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。
	所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
 * 
 * 
 */


import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class Test {
	public static void main(String[] args) {
		ExecutorService executor = Executors.newCachedThreadPool();   // 线程池
		for (int i = 0; i < 5; i++) {
			Callable<VideoInfo> c = new TaskCallable();
			MyFutureTask ft = new MyFutureTask(c);
			executor.submit(ft);  // 执行子线程
			System.out.println("this is main thread...");   // 主线程继续执行
		}
		executor.shutdown(); // 不再往线程池中加入新的执行对象
	}

}

/**
 * FutureTask类是Future 的一个实现，并实现了Runnable，所以可通过Excutor(线程池) 来执行,也可传递给Thread对象执行。
 * callable接口执行完成后回调done（）方法，同时可以通过get()方法获得callable接口的返回值
 *
 */
class MyFutureTask extends FutureTask<VideoInfo> {

	public MyFutureTask(Callable<VideoInfo> callable) {
		super(callable);
	}

	@Override
	protected void done() {    //
		try {
			System.out.println("MyFutureTask done() : "+get()); 
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
	}

	@Override
	public VideoInfo get() throws InterruptedException, ExecutionException {
		System.out.println("这里面可以修饰一下返回结果。。。");
		VideoInfo videoInfo =  super.get();
		videoInfo.setName(videoInfo.getName() + "_??");
		return videoInfo;
	}
}

/**
 * Callable接口则提供了一种有返回值的多线程实现方法.
 *
 */
class TaskCallable implements Callable<VideoInfo> {

	private String threadName;

	public TaskCallable(String threadName){
		this.threadName = threadName;
	}

	public TaskCallable(){
	}

	@Override
	public VideoInfo call() throws Exception {
		Thread.currentThread().sleep(3000);
		VideoInfo videoInfo = new VideoInfo();
		videoInfo.setId("adfad");
		videoInfo.setName("name");
		videoInfo.setThreadName("线程名称 :" + Thread.currentThread().getName());
		return videoInfo;
	}
}

class VideoInfo {
	private String name;
	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * @return the id
	 */
	public String getId() {
		return id;
	}
	/**
	 * @param id the id to set
	 */
	public void setId(String id) {
		this.id = id;
	}
	private String id;
	
	private String threadName;
	

	/**
	 * @return the threadName
	 */
	public String getThreadName() {
		return threadName;
	}
	/**
	 * @param threadName the threadName to set
	 */
	public void setThreadName(String threadName) {
		this.threadName = threadName;
	}
	@Override
	public String toString() {
		return "VideoInfo [name=" + name + ", id=" + id +  ", threadName=" + threadName+"]";
	}
}