适AT Java线程池（ThreadPool）详解

发布时间：2017-07-05 11:06:35.17 作者： IT网络文摘 (该文来自笔记，点击查看原文)

线程五个状态（生命周期）：

万码学堂,电脑培训,计算机培训,Java培训,JavaEE开发培训,青岛软件培训,软件工程师培训

线程运行时间

　　　　假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。

　　　如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。

线程池技术

　　一个线程池包括以下四个基本组成部分

　　　　　　1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务；

2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；

3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；

4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。

　　线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。
　　线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：
　　假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

java并发编程：线程池的使用

　我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：

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

　　那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？

　　在Java中可以通过线程池来达到这样的效果。下面我们就来详细讲解一下Java的线程池，首先我们从最核心的ThreadPoolExecutor类中的方法讲起，然后再讲述它的实现原理，接着给出了它的使用示例，最后讨论了一下如何合理配置线程池的大小。

　　本文的目录大纲：

　　一.Java中的ThreadPoolExecutor类

　　二.深入剖析线程池实现原理

　　三.使用示例

　　四.如何合理配置线程池的大小　

　　若有不正之处请多多谅解，并欢迎批评指正。　

一.Java中的ThreadPoolExecutor类

　　java.uitl.concurrent.ThreadPoolExecutor类是线程池中最核心的一个类，因此如果要透彻地了解Java中的线程池，必须先了解这个类。下面我们来看一下ThreadPoolExecutor类的具体实现源码。

　　在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);

　　从上面的代码可以得知，ThreadPoolExecutor继承了AbstractExecutorService类，并提供了四个构造器，事实上，通过观察每个构造器的源码具体实现，发现前面三个构造器都是调用的第四个构造器进行的初始化工作。

　　下面解释下一下构造器中各个参数的含义：

corePoolSize：核心池的大小，这个参数与后面讲述的线程池的实现原理有非常大的关系。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程；
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池中的线程数不大于corePoolSize：即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize；但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性，以及TimeUtil的源码展示：

TimeUnit.DAYS;               TimeUnit.HOURS;             TimeUnit.MINUTES;           TimeUnit.SECONDS;           TimeUnit.MILLISECONDS;      TimeUnit.MICROSECONDS;      TimeUnit.NANOSECONDS;

public enum TimeUnit {
    NANOSECONDS {        public long toNanos(long d)   { return d; }        public long toMicros(long d)  { return d/(C1/C0); }        public long toMillis(long d)  { return d/(C2/C0); }        public long toSeconds(long d) { return d/(C3/C0); }        public long toMinutes(long d) { return d/(C4/C0); }        public long toHours(long d)   { return d/(C5/C0); }        public long toDays(long d)    { return d/(C6/C0); }        public long convert(long d, TimeUnit u) { return u.toNanos(d); }        int excessNanos(long d, long m) { return (int)(d - (m*C2)); }
    },
    MICROSECONDS {        public long toNanos(long d)   { return x(d, C1/C0, MAX/(C1/C0)); }        public long toMicros(long d)  { return d; }        public long toMillis(long d)  { return d/(C2/C1); }        public long toSeconds(long d) { return d/(C3/C1); }        public long toMinutes(long d) { return d/(C4/C1); }        public long toHours(long d)   { return d/(C5/C1); }        public long toDays(long d)    { return d/(C6/C1); }        public long convert(long d, TimeUnit u) { return u.toMicros(d); }        int excessNanos(long d, long m) { return (int)((d*C1) - (m*C2)); }
    },
    MILLISECONDS {        public long toNanos(long d)   { return x(d, C2/C0, MAX/(C2/C0)); }        public long toMicros(long d)  { return x(d, C2/C1, MAX/(C2/C1)); }        public long toMillis(long d)  { return d; }        public long toSeconds(long d) { return d/(C3/C2); }        public long toMinutes(long d) { return d/(C4/C2); }        public long toHours(long d)   { return d/(C5/C2); }        public long toDays(long d)    { return d/(C6/C2); }        public long convert(long d, TimeUnit u) { return u.toMillis(d); }        int excessNanos(long d, long m) { return 0; }
    },
    SECONDS {        public long toNanos(long d)   { return x(d, C3/C0, MAX/(C3/C0)); }        public long toMicros(long d)  { return x(d, C3/C1, MAX/(C3/C1)); }        public long toMillis(long d)  { return x(d, C3/C2, MAX/(C3/C2)); }        public long toSeconds(long d) { return d; }        public long toMinutes(long d) { return d/(C4/C3); }        public long toHours(long d)   { return d/(C5/C3); }        public long toDays(long d)    { return d/(C6/C3); }        public long convert(long d, TimeUnit u) { return u.toSeconds(d); }        int excessNanos(long d, long m) { return 0; }
    },
    MINUTES {        public long toNanos(long d)   { return x(d, C4/C0, MAX/(C4/C0)); }        public long toMicros(long d)  { return x(d, C4/C1, MAX/(C4/C1)); }        public long toMillis(long d)  { return x(d, C4/C2, MAX/(C4/C2)); }        public long toSeconds(long d) { return x(d, C4/C3, MAX/(C4/C3)); }        public long toMinutes(long d) { return d; }        public long toHours(long d)   { return d/(C5/C4); }        public long toDays(long d)    { return d/(C6/C4); }        public long convert(long d, TimeUnit u) { return u.toMinutes(d); }        int excessNanos(long d, long m) { return 0; }
    },
    HOURS {        public long toNanos(long d)   { return x(d, C5/C0, MAX/(C5/C0)); }        public long toMicros(long d)  { return x(d, C5/C1, MAX/(C5/C1)); }        public long toMillis(long d)  { return x(d, C5/C2, MAX/(C5/C2)); }        public long toSeconds(long d) { return x(d, C5/C3, MAX/(C5/C3)); }        public long toMinutes(long d) { return x(d, C5/C4, MAX/(C5/C4)); }        public long toHours(long d)   { return d; }        public long toDays(long d)    { return d/(C6/C5); }        public long convert(long d, TimeUnit u) { return u.toHours(d); }        int excessNanos(long d, long m) { return 0; }
    },
    DAYS {        public long toNanos(long d)   { return x(d, C6/C0, MAX/(C6/C0)); }        public long toMicros(long d)  { return x(d, C6/C1, MAX/(C6/C1)); }        public long toMillis(long d)  { return x(d, C6/C2, MAX/(C6/C2)); }        public long toSeconds(long d) { return x(d, C6/C3, MAX/(C6/C3)); }        public long toMinutes(long d) { return x(d, C6/C4, MAX/(C6/C4)); }        public long toHours(long d)   { return x(d, C6/C5, MAX/(C6/C5)); }        public long toDays(long d)    { return d; }        public long convert(long d, TimeUnit u) { return u.toDays(d); }        int excessNanos(long d, long m) { return 0; }
    };
    static final long C0 = 1L;    static final long C1 = C0 * 1000L;    static final long C2 = C1 * 1000L;    static final long C3 = C2 * 1000L;    static final long C4 = C3 * 60L;    static final long C5 = C4 * 60L;    static final long C6 = C5 * 24L;    static final long MAX = Long.MAX_VALUE;
    static long x(long d, long m, long over) {        if (d >  over) return Long.MAX_VALUE;        if (d < -over) return Long.MIN_VALUE;        return d * m;
    }
    public long convert(long sourceDuration, TimeUnit sourceUnit) {        throw new AbstractMethodError();
    }
    public long toNanos(long duration) {        throw new AbstractMethodError();
    }
    public long toMicros(long duration) {        throw new AbstractMethodError();
    }
    public long toMillis(long duration) {        throw new AbstractMethodError();
    }
    public long toSeconds(long duration) {        throw new AbstractMethodError();
    }
    public long toMinutes(long duration) {        throw new AbstractMethodError();
    }
    public long toHours(long duration) {        throw new AbstractMethodError();
    }
    public long toDays(long duration) {        throw new AbstractMethodError();
    }
    public void timedWait(Object obj, long timeout)            throws InterruptedException {        if (timeout > 0) {            long ms = toMillis(timeout);            int ns = excessNanos(timeout, ms);
            obj.wait(ms, ns);
        }
    }
    public void timedJoin(Thread thread, long timeout)            throws InterruptedException {        if (timeout > 0) {            long ms = toMillis(timeout);            int ns = excessNanos(timeout, ms);
            thread.join(ms, ns);
        }
    }
    public void sleep(long timeout) throws InterruptedException {        if (timeout > 0) {            long ms = toMillis(timeout);            int ns = excessNanos(timeout, ms);
            Thread.sleep(ms, ns);
        }
    }

}

万码学堂,电脑培训,计算机培训,Java培训,JavaEE开发培训,青岛软件培训,软件工程师培训 http://www.cnblogs.com/kuoAT/p/6714762.html{

此文章感谢作者--海子:http://www.cnblogs.com/dolphin0520/p/3932921.html

　　　　　　 --Hsuxu:http://blog.csdn.net/hsuxu/article/details/8985931

分类导航

适AT Java线程池（ThreadPool）详解

线程五个状态（生命周期）：

线程运行时间

线程池技术

一.Java中的ThreadPoolExecutor类

延伸阅读

我想了解如何学习