java中的线程池

当我们在执行任务的时候去创建线程，这样实现起来非常简单。
但是在并发的线程非常多的时候，并且每个线程执行一个时间很短的任务就结束了，这样频繁的创建线程，大大降低了系统的效率，因为创建线程和销毁线程需要消耗时间和系统的cpu。
java中可以使用线程池是得线程可以复用，就是说完成一个任务，并不销毁，还可以去执行其他的任务。java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类，这个类提供了四种线程池供我们使用。这四种方法分别是：
1.newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
2.newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
3.newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
4.newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

给出例子：

package com.zhangyike.threadPool;

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

/*
 * 线程池
 */
public class ThreadPool01 {
    public static void main(String[] args) {
        singelThread();
    }

    //固定的线程池。
    public static void fixedThreadPool(){
        //创建线程池，线程池中有3个线程,这三个线程是不会自动停止的，一直在跑，如果想让他停止必须手动
        ExecutorService pool = Executors.newFixedThreadPool(3);

        //向线程池中抛入了10个任务，但是线程池只有三个线程，这10个任务由这三个线程去完成
        for (int j = 0; j < 10; j++) {
            final int task = j;
            //向线程池中放入任务
            pool.execute(new Runnable(){

                @Override
                public void run() {
                /*  try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }*/
                    for (int i = 0; i < 10; i++) {
                        //内部类中访问外部类中的数据，该数据必须是final修饰
                        System.out.println(Thread.currentThread().getName() + ",is loop of i = " + i + ", for task of task = " + task);
                    }

                }
            });

        }
        //任务全部完成，停止所以的线程
        pool.shutdown();
        //每个线程执行一个任务，执行结束后，线程自动死亡
        pool.shutdownNow();
    }

    //不固定的线程池，当任务多的时候，线程池会自动的增加线程，去处理任务。
    public static void unfixedThreadPool() {
        //会自动的向线程中添加任务
        ExecutorService pool = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            final int task = i;

            pool.execute(new Runnable() {

                @Override
                public void run() {
                    for (int j = 0; j < 10; j++) {
                        System.out.println(Thread.currentThread().getName() + ", loop of j = " + j + ", excute task = " + task);
                    }
                }
            });
        }

        System.out.println("all task is finished!");
        pool.shutdown();
    }

    //单个线程，保证线程池中只有一个线程，当这个线程死了，会找一个线程来替补他
    //这个线程死了， 能给他活过来
    public static void singelThread() {
        ExecutorService single = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 10; i++) {
            final int task = i;
            single.execute(new Runnable() {

                @Override
                public void run() {
                    for (int j = 0; j < 10; j++) {
                        System.out.println(Thread.currentThread().getName() + ", loop of j = " + j + ", excute task = " + task);
                    }
                }
            });
        }
        System.out.println("all task is finished!");
        single.shutdown();
    }

//定时线程池
public static void timerThread(){           Executors.newScheduledThreadPool(3).scheduleAtFixedRate(new Runnable(){

            @Override
            public void run() {
                System.out.println("boming...");

            }

        }, 10, 2, TimeUnit.SECONDS);//10秒后第一次运行，以后每次每隔2秒运行一次。

    }
}