以下的笔记是我的体会，经过几次回看视频，的总结。有什么不懂的，我再学习学习
package cn.itcast.day3.thread;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureTest {

        /**
         * @param args
         */
        public static void main(String[] args) {
                System.out.println("---------------------------");                //开始
               
                ExecutorService executor = Executors.newSingleThreadExecutor();//做出这个单线程
                executor.execute(new Runnable(){                        //然后执行一个任务。
                        public void run(){
                                try {
                                        Thread.sleep(5000);
                                } catch (InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                                System.out.println("hello");
                        }
                });
                //executor.shutdown();
                System.out.println("---------------------------");                //结束。
                ExecutorService executor1 = Executors.newFixedThreadPool(3);        //做出这个线程池，固定有3个线程。
                for(int i=1;i<=10;i++){                                                                        //提交10个任务。因为池子里有3个空闲线程，所以它们被拿去干活了。
                        final int seq = i;
                        Future<Integer> future =                                 //返回的结果是一个Future对象。这个对象有方法可以获取返回的结果
                                        executor1.submit(new Callable<Integer>() {
                                
                                @Override
                                public Integer call() throws Exception {
                                        Thread.sleep(new Random().nextInt(4000));
                                        return seq;
                                }
                        });
                        
                        
                        System.out.println("wait for the result");
                        try {
                                System.out.println("get  "+future.get());
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        } catch (ExecutionException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                }
               
                System.out.println("---------------------------");                //开始结束标志
               
                ExecutorCompletionService<Integer> cs = new ExecutorCompletionService<Integer>(
                                Executors.newFixedThreadPool(5)
                                );                                        //不懂具体意思，反正知道这个cs，里面有一个线程池，这个池子有5个线程可以使用。
               
                for(int i=1;i<=10;i++){                        //提交了10个任务，并且每个任务什么时候完成，人并不知道。
                        final int seq = i;
                        cs.submit(
                                        new Callable<Integer>() {
        
                                                @Override
                                                public Integer call() throws Exception {
                                                        Thread.sleep(new Random().nextInt(4000));
                                                        return seq;
                                                }
                                        }
                                        );
                        }
                        
                        try {
                                for(int j=0;j<10;j++)
                                        System.out.println(cs.take().get());                //不管谁先执行完，就获取谁的返回结果。
                        } catch (Exception e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
               
                System.out.println("---------------------------");
        }

}

/*
* Callable 是一个接口，和Runnable非常相似，不同的是它有返回值。
* 通过ExecutorService对象的submit方法，提交任务。
* 通过Future 对象的get方法获得这个任务的结果。
*
* 还有通过一次性设置几个任务，哪个任务先返回结果就先获得哪个任务的结果。如果都还没有返回结果，就先执行别的代码，这种思想的代码可以用到一个类，
*
* 这个类就是ExecutorCompletionService，具体实现看上面代码。
*
*/

值得学习inng!

创建线程的第三种方式～  挺好用的