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());