Runnable,Callable,Future,RunnableFuture,FutureTask,ExecutorService的关系

关系

Executor就是Runnable和Callable的调度容器，Future就是对于具体的调度任务的执行结果进行查看，最为关键的是Future可以检查对应的任务是否已经完成，也可以阻塞在get方法上一直等待任务返回结果。Runnable和Callable的差别就是Runnable是没有结果可以返回的，就算是通过Future也看不到任务调度的结果的。 

FutureTask则是一个RunnableFuture<V>，即实现了Runnbale又实现了Futrue<V>这两个接口，另外它还可以包装Runnable和Callable<V>，所以一般来讲是一个符合体了，它可以通过Thread包装来直接执行，也可以提交给ExecuteService来执行，并且还可以通过v get()返回执行结果，在线程体没有执行完成的时候，主线程一直阻塞等待，执行完则直接返回结果。

开启线程的几种方法:

1.通过继承Thread类开启线程

  /**
     * 通过继承Thread类开启线程
     */
    private void extendsThread() {
        new MyThread().start();
    }

    class MyThread extends Thread{
        @Override
        public void run() {
            super.run();

            System.out.println("通过继承Thread类开启线程");
        }
    }

2.Runnable+Thread

  /**
     * 通过new Thread(runnable)开启线程
     */
    private void runnableThread() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("通过new Thread(runnable)开启线程");
            }
        }).start();
    }

3.Callable+FutureTask+Thread

    /**
     * 通过new Thread(new FutureTask(callable))开启线程
     */
    private void callableFutureTaskThread() {
        FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("通过new Thread(new FutureTask(callable))开启线程");
                return "finish 通过new Thread(new FutureTask(callable))开启线程";
            }
        });
        new Thread(futureTask).start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

4.ExecutorService+Callable+Future

 /**
     * 通过 executorService.submit(callable)并且return一个Future开启线程
     */
    private void executorServiceCallableFuture() {
        ExecutorService executorService = Executors.newFixedThreadPool(5);//创建一个可重用固定线程数的线程池;
        Future<String> future = executorService.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("通过 executorService.submit(callable)并且return一个Future开启线程");
                return "finish 通过 executorService.submit(callable)并且return一个Future开启线程";
            }
        });
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

5.ExecutorService+Runnable+Future

 /**
     * 通过 executorService.submit(runnable,T)并且return一个Future开启线程
     */
    private void executorServiceRunnableFuture() {
        ExecutorService executorService = Executors.newFixedThreadPool(5);//创建一个可重用固定线程数的线程池;
        Future<String> future = executorService.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("通过 executorService.submit(runnable,T)并且return一个Future开启线程");
            }
        },"finish 通过 executorService.submit(runnable,T)并且return一个Future开启线程");
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

6.ExecutorService+FutureTask

 /**
     * 通过 executorService.submit(futureTask)开启线程
     */
    private void executorServiceFutureTask() {
        ExecutorService executorService = Executors.newFixedThreadPool(5);//创建一个可重用固定线程数的线程池;
        FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("通过 executorService.submit(futureTask)开启线程");
                return "通过 executorService.submit(futureTask)开启线程";
            }
        });
        executorService.submit(futureTask);
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }