线程池复习笔记

1. 线程池是什么？

    线程池是预先创建线程的一种技术。线程池在还没有任务到来之前，创建一定数量的线程，放入空闲队列中。这些线程都是处于睡眠状态，即均未启动，不消耗CPU，而只是占用较小的内存空间。当请求到来之后，

    缓冲池给这次请求分配一个空闲线程，把请求传入此线程中运行，进行处理。当预先创建的线程都处于运行状态，即预制线程不够，线程池可以自由创建一定数量的新线程，用于处理更多的请求。当系统比较闲的时候，

    也可以通过移除一部分一直处于停用状态的线程。

2. 为什么使用线程池？

    如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。

3. 与**有什么不同？

4. 骨架

    1). java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类

    2). corePoolSize：核心池的大小。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，

         从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个

         线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；   

    3). maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；  

    4). keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize，

         即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法，

         在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；

    5). unit：参数keepAliveTime的时间单位，时分秒等

    6). workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响。ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用

         LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

    7). threadFactory：线程工厂，主要用来创建线程；

    8). handler：表示当拒绝处理任务时的策略，有以下四种取值：丢弃并抛异常，丢弃不抛异常，丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程），由调用线程处理该任务

5. 线程池怎么用？    

public class Test {
     public static void main(String[] args) {   
         ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                 new ArrayBlockingQueue<Runnable>(5));
          
         for(int i=0;i<15;i++){
             MyTask myTask = new MyTask(i);
             executor.execute(myTask);
             System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+
             executor.getQueue().size()+"，已执行玩别的任务数目："+executor.getCompletedTaskCount());
         }
         executor.shutdown();
     }
}
 
 
class MyTask implements Runnable {
    private int taskNum;
     
    public MyTask(int num) {
        this.taskNum = num;
    }
     
    @Override
    public void run() {
        System.out.println("正在执行task "+taskNum);
        try {
            Thread.currentThread().sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task "+taskNum+"执行完毕");
    }
}

6. 使用注意事项

    1). 给线程命名，便于监控，推荐使用下面的提供的线程工厂

    2). 当workQueue为LinkedBlockingQueue时有内存溢出的风险；一种解决方法是使用Synchronous，不将线程任务放到队列中，当无可用线程时抛出异常，捕获，休眠一秒。

    3). 默认情况下，创建线程池之后，线程池中是没有线程的，需要提交任务之后才会创建线程。在实际中如果需要线程池创建之后立即创建线程，可以通过以下两个方法办到：

         prestartCoreThread()：初始化一个核心线程；

         prestartAllCoreThreads()：初始化所有核心线程

    4). 要知道任务提交给线程池之后的处理策略，这里总结一下主要有4点：

         a. 如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；

         b. 如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），

             则会尝试创建新的线程去执行这个任务；

         c. 如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；

         d. 如果线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，

             那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

7. 优化

    1). 给线程命名，便于监控，推荐使用下面的提供的线程工厂

    2). 如何合理配置线程池大小，仅供参考。

　　   一般需要根据任务的类型来配置线程池大小：

　　   如果是CPU密集型任务，就需要尽量压榨CPU，参考值可以设为 N_CPU+1

　　   如果是IO密集型任务，参考值可以设置为2*N_CPU

　　   当然，这只是一个参考值，具体的设置还需要根据实际情况进行调整，比如可以先将线程池大小设置为参考值，再观察任务运行情况和系统负载、资源利用率来进行适当调整。

    3). ThreadPoolExecutor提供了动态调整线程池容量大小的方法：setCorePoolSize()和setMaximumPoolSize()，

8. 监控

    visualVM

在ThreadPoolExecutor类中提供了四个构造方法：

public class ThreadPoolExecutor extends AbstractExecutorService {
    .....
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
    ...
}

创建线程工厂：

BasicThreadFactory threadFactory = new BasicThreadFactory.Builder().daemon(false).namingPattern("mms7Client-%d").build();

exec = new ThreadPoolExecutor(2, config.getThreadNumber(), 60L,TimeUnit.SECONDS, new SynchronousQueue<Runnable>(),threadFactory);

线程池复习笔记

原文：http://www.cnblogs.com/Jtianlin/p/5191222.html