比较java中Future与FutureTask之间的关系

public interface future<v> {

  boolean cancel( boolean mayinterruptifrunning);

  boolean iscancelled();

  boolean isdone();

  v get() throws interruptedexception, executionexception;

  v get( long timeout, timeunit unit)

   throws interruptedexception, executionexception, timeoutexception;

}

public class futuretask<v> implements runnablefuture<v>｛

   public futuretask(callable<v> callable) {

   if (callable == null )

    throw new nullpointerexception();

   this .callable = callable;

   this .state = new ;  // ensure visibility of callable

   }

   public futuretask(runnable runnable, v result) {

   this .callable = executors.callable(runnable, result); //runnable转化为callable

   this .state = new ;  // ensure visibility of callable

   }

｝

// 执行任务 实现runnable

  futuretaskjobrunnable taskrun = new futuretaskjobrunnable();

  // 执行任务 实现callable

  futuretaskjobcallable taskcall = new futuretaskjobcallable();

  string val = "ok" ;

  // 线程运行成功后把,返回你传入的val值

  futuretask<string> futuretaskrun = new futuretask<string>(taskrun, val);

  // 线程运行，返回线程执行的结果

  futuretask<string> futuretaskcall = new futuretask<string>(taskcall);

  //声明线程池

  executorservice executor = executors.newcachedthreadpool(); 

  //future

  future<string> future = executor.submit(taskcall);

  system.out.println(future.get());

  //futuretask

  executor.submit(futuretaskcall);

  system.out.println(futuretaskcall.get());

  //futuretask自定义线程执行

  new thread(futuretaskrun).start();

  system.out.println(futuretaskrun.get());

public class futuretaskjobcallable implements callable<string>{

  public string call() throws exception {

   system.out.println( "futuretaskjobcallable已经执行了哦" );

   thread.sleep( 1000 );

   return "返回结果" ;

  }

}

public class futuretaskjobrunnable implements runnable {

  public void run() {

   try {

    thread.sleep( 1000 );

   } catch (interruptedexception e) {

    // todo auto-generated catch block

    e.printstacktrace();

   }

   system.out.println( "futuretaskjobrunnable已经执行了哦" );

  }

}

public future<?> submit(runnable task) {

   if (task == null ) throw new nullpointerexception();

   runnablefuture< void > ftask = newtaskfor(task, null );

   execute(ftask);

   return ftask;

  }

  public <t> future<t> submit(runnable task, t result) {

   if (task == null ) throw new nullpointerexception();

   runnablefuture<t> ftask = newtaskfor(task, result);

   execute(ftask);

   return ftask;

  }

  public <t> future<t> submit(callable<t> task) {

   if (task == null ) throw new nullpointerexception();

   runnablefuture<t> ftask = newtaskfor(task);

   execute(ftask);

   return ftask;

  }

  protected <t> runnablefuture<t> newtaskfor(runnable runnable, t value) {

   return new futuretask<t>(runnable, value);

  }

  protected <t> runnablefuture<t> newtaskfor(callable<t> callable) {

   return new futuretask<t>(callable);

  }

//你传入的runnable与callable实现类都会在构造函数中转化为callable

private callable<v> callable;

  public void run() {

   if (state != new ||

    !unsafe测试数据pareandswapobject( 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);

   }

  }