java 线程池的四实现方法

近期项目上要用到多线程技术，就找时间有学习了一下。
上代码：
1.缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。 线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

 executorService = Executors.newCachedThreadPool();
        //for中开 多线程

        for (int i = 0; i < 10; i++) {
            final int count = i;
            Runnable runnable =  new Runnable() {  

                @Override
                public void run() {

                    System.out.println("线程");
                }
            };
            executorService.submit(runnable);
        }
        executorService.shutdown(); 

        while(true){
        //当线程中的所有线程动结束后 这为true
            if(executorService.isTerminated()){
                System.out.println(count+"线程全部关闭状态！");
                break;
            }
        }

2.定长线程池 可以控制线程的并发量，超出是会在线程列队中等待。因为线程池大小为5(最多开5个线程跑)，每个任务输出index后sleep 2秒，所以每两秒打印5个数字

ExecutorService executorfixed = Executors.newFixedThreadPool(5);

        for (int i = 0; i <20; i++) {
            final int index = i;

            Runnable runnable2 =  new Runnable() {

                @Override
                public void run() {
                    System.out.println("线程"+index);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            };
            executorfixed.submit(runnable2);
        }

3.定长（并定时）线程池，支持定时，周期性的任务。可以循环执行，定时执行。非常方便

ScheduledExecutorService executorScheduled = Executors.newScheduledThreadPool(5);
        //  案例1.  表示延迟3秒执行。运行到这个方法是 先等待三秒 在执行多线程。
        for (int i = 0; i < 25; i++) {
        final int zhi = i;  
        executorScheduled.schedule(new Runnable() {

            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println("小鸡吃"+zhi+"米");
                Thread.sleep(1000);
            }
        } ,3, TimeUnit.SECONDS);
        }

        //案例2  表示5秒后执行线程池中的线程, 每3秒一次运行。5秒只在刚调入这个方法是执行一边（不会跟着 循环执行的线程池 而执行）
        //   简单说 延迟5秒后  每3秒运行一次
        for (int i = 0; i < 12; i++) {
            final int is = i;
            executorScheduled.scheduleWithFixedDelay(new Runnable() {

                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    System.out.println("小鸭吃"+is+"米");
                }
            }, 5, 3, TimeUnit.SECONDS);
        }

4.这个是单一线程池（是个单例模式的） 这个就是一个接一个的执行。

ExecutorService executorSingle = Executors.newSingleThreadExecutor();
        for (int i = 0; i <15; i++) {
            final int myi = i;
            executorSingle.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println("我的线程："+myi);
                    try {
                        Thread.sleep(2500);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            });
        }
        }

我这次使用的是 第 1 个方法。感觉还是很好用的。
下面介绍一下第一个方法使用到的一些参数，及作用。说的不对的，告诉一声。
executorService 线程池管理工具类
Executors.newCachedThreadPool() 创建缓存线程池
Runnable 创建线程对象，并在run方法中添加操作代码。
.submit() 执行该行程，并这个方法可以有返回值。（execute()方法是一样都是添加线程到线程池中但是execute没有返回值）

executorService.shutdown();停止接受新任务 已经接受的任务会值新 .shutdowmNow()调用这个方法，停止接受新任务，已经接受的任务会被删掉。关闭执行服务对象

.isTerminated() 当线程池中的线程全部结束后 结果为true。（可以去取所有线程的返回值，如果没有返回值可以使用executorSingle.execute(）方法）