具体看注释的介绍第一个例子：

/**
     * 固定大小的线程池
     *
     * 同时可以处理【参数】个任务，多余的任务会排队，当处理完一个马上就会去接着处理排队中的任务。
     * Callable的任务在后面的blog有更详细的文章说明
     */
    private static void fixedThreadPool(){
 
        long startTime = System.currentTimeMillis();
        // TODO 创建20个线程
        ExecutorService es = Executors.newFixedThreadPool(20);
 
 
        // TODO callable way
        for(int i=1; i <= 1000; i++){
            final int task = i;
            Future<Integer> future = es.submit(new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    int status = 0;
                    try {
                        Thread.sleep(100);
                        Car car = new Car();
                        car.setGeoCode("12");
                        // TODO 加入自己写的接口
                        // status= carService.save(car);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return status;
                }
            });
 
        }
        // TODO 结束所有线程
        es.shutdown();
 
        // TODO 这个方法是统计所有线程全部执行完毕的时间
        while(true){
            if(es.isTerminated()){
                long end = System.currentTimeMillis();
                System.out.println("20个线程执行用时: " + (end - startTime) + "ms");
                break;
            }
        }
 
 
        // TODO 以下是单线成保存1000条记录的时间
        long startTime1 = System.currentTimeMillis();
        for (int f = 0; f < 1000; f++) {
            Car car = new Car();
            car.setGeoCode("12");
            // TODO 换成自己的实现类即可
            // carService.save(car);
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("执行时间单线程" + (endTime1 - startTime1) + "ms");
        // TODO runnable 没有线程返回值不做具体详解
//        for(int i=1 ; i<5000; i++){
//            final int task = i;
//            es.execute(new Runnable() {
//                @Override
//                public void run() {
//                    for(int j=1; j<=2000; j++){
//                        System.out.println(Thread.currentThread().getName());
//                        try {
//                            Thread.sleep(100);
//                        } catch (Exception e) {
//                            e.printStackTrace();
//                        }
//                    }
//                }
//            });
//        }
//        long endTime = System.currentTimeMillis();
//        System.out.println((endTime - startTime) + "ms");
    }

第二个例子：

package myUtil.myUtil;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * 
 * 自我感觉最实用的线程，固定长度线程池总结
 *以及优点
 */
public class MyTest{  
    private static final Logger logger = LoggerFactory
            .getLogger(MyTest.class);
    
    public static void main(String[] argv){  
        //创建线程本地变量
        ThreadLocal<String> threadLocal = new ThreadLocal<String>();
        /*创建可用线程数量的固定线程池*/
        ExecutorService executorService =  Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        executorService.execute(new Runnable() {//向线程池中添加线程
            @Override
            public void run() {//一定要捕获子线程异常，不然它出轨了都不知道
                try {
                
                } catch (Exception e) {
                
                }
            }
        });
        executorService.shutdown();//一定要调用这个方法，不然executorService.isTerminated()永远不为true
        while(true){//等待所有任务都结束了继续执行
            try {
                if(executorService.isTerminated()){
                    System.out.println("所有的子线程都结束了！");
                    break;
                }
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }  
}