java 并发runable,callable,future,futureTask

转载自：http://www.cnblogs.com/dolphin0520/p/3949310.html

package future_call;

import java.util.concurrent.Callable;

/**
 * Created by luozhitao on 2017/8/10.
 */
public class Task implements Callable<Integer> {
  //  @Override
    public Integer call() throws Exception {

        System.out.println("子线程在进行计算");

        Thread.sleep(10000);
        System.out.println("子线程睡眠完毕");
        int sum=0;
        for (int i=0;i<100;i++){

            sum+=i;

        }

        return sum;
    }
}

1.使用Callable+Future

package future_call;

import java.util.concurrent.*;

/**
 * Created by luozhitao on 2017/8/10.
 */
public class Task_test {

    public static void main(String [] args){

        ExecutorService executorService= Executors.newCachedThreadPool();
        Task task=new Task();
        Future<Integer> future=null;
        try{
           // executorService

            future=executorService.submit(task);
            System.out.println("线程池关闭之前");
            executorService.shutdown();
            System.out.println("线程池关闭之后");

        }catch (RejectedExecutionException e){System.out.println(e);}

        try{

           Thread.sleep(1000);

        }catch (InterruptedException e){e.printStackTrace();}

        System.out.println("主线程在进行计算");

        try{

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

        }catch (InterruptedException e){e.printStackTrace();} catch (ExecutionException e){e.printStackTrace();}

    }
}

2.使用Callable+FutureTask

package future_call;

import java.util.concurrent.*;

/**
 * Created by luozhitao on 2017/8/10.
 */
public class future_task1 {

    public static void main(String [] args){

        ExecutorService executorService= Executors.newCachedThreadPool();
        Task task=new Task();
        FutureTask<Integer> futureTask=new FutureTask<Integer>(task);
        try {
            /*
            executorService.submit(futureTask);
            executorService.shutdown();
            */
            Thread thread=new Thread(futureTask);
            thread.start();

        }catch (RejectedExecutionException e){e.printStackTrace();}

        try {
            Thread.sleep(1000);
            System.out.println("主线程睡眠完毕");
        }catch (InterruptedException e){e.printStackTrace();}

        try{

            System.out.println(futureTask.get());

        }catch (InterruptedException e){e.printStackTrace();}catch (ExecutionException e){e.printStackTrace();}

    }

}

如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。

/**
             * 提交runnable则没有返回值, future没有数据
             */
            Future<?> result = mExecutor.submit(new Runnable() {  

                @Override
                public void run() {
                    fibc(20);
                }
            });  

            System.out.println("future result from runnable : " + result.get());