实现Callable接口

  import java.util.concurrent.Callable;
  import java.util.concurrent.FutureTask;

  public class CallableTest {
      public static void main(String[] args) {
          Callable call = new MyCallable();
          FutureTask<String> task = new FutureTask<>(call);
          Thread t = new Thread(task);
          t.start();

          // 通过futuretask可以得到 MyCallable 的 call() 的运行结果：
          futuretask.get();
      }
  }

 class MyCallable implements Callable<String> {
      //重写线程任务类方法
      @Override
      public String call() throws Exception {
          return Thread.currentThread().getName() + "->" + "Hello World";
      }
  }

实现 Callable 接口步骤：

1、定义一个线程任务类实现 Callable 接口，申明线程执行的结果类型

2、重写线程任务类的 call 方法，这个方法可以直接返回执行的结果

3、创建一个 Callable 的线程任务对象

4、把 Callable 的线程任务对象包装成一个未执行任务对象

5、把未执行任务对象包装成线程对象

6、调用线程的 start() 方法启动线程

通过FutureTask类和Callable接口的联合使用可以创建能够获取异步执行结果的线程，具体步骤如下：

（1）创建一个Callable接口的实现类，并实现其call()方法，编写好异步执行的具体逻辑，可以有返回值

（2）使用Callable实现类的实例构造一个FutureTask实例

（3）使用FutureTask实例作为Thread构造器的target入参，构造新的Thread线程实例

（4）调用Thread实例的start()方法启动新线程，启动新线程的run()方法并发执行；其内部的执行过程为：启动Thread实例的run()方法并发执行后，会执行FutureTask实例的run()方法，最终会并发执行Callable实现类的call()方法

步骤一、Thread类

    public Thread(Runnable target) {
    	init(null, target, "Thread-" + nextThreadNum(), 0);
    }

    @Override
    public void run() {
    	if (target != null) {
    		target.run(); // 调用了FutureTask类下的run()方法
    	}
    }

步骤二、FutureTask类

      public FutureTask(Callable<V> callable) {
      	if (callable == null)
      		throw new NullPointerException();
      	this.callable = callable;
      	this.state = NEW;       // ensure visibility of callable
      }

      public void run() {
      	if (state != NEW ||
      		!UNSAFE.compareAndSwapObject(this, runnerOffset,
      									 null, Thread.currentThread()))
      		return;
      	try {
      		Callable<V> c = callable;
      		if (c != null && state == NEW) {
      			V result;
      			boolean ran;
      			try {
      				result = c.call();
      				ran = true;
      			} catch (Throwable ex) {
      				result = null;
      				ran = false;
      				setException(ex);
      			}
      			if (ran)
      				set(result);
      		}
      	} finally {
      		// runner must be non-null until state is settled to
      		// prevent concurrent calls to run()
      		runner = null;
      		// state must be re-read after nulling runner to prevent
      		// leaked interrupts
      		int s = state;
      		if (s >= INTERRUPTING)
      			handlePossibleCancellationInterrupt(s);
      	}
      }

步骤三、Callable接口

    public interface Callable<V> {
        /**
         * Computes a result, or throws an exception if unable to do so.
         *
         * @return computed result
         * @throws Exception if unable to compute a result
         */
        V call() throws Exception;
    }