Java线程池实现原理,java中线程池原理

　　00-1010线程池定义和使用的由来方案一：Executors(仅供理解，推荐方案二)方案二：ThreadPoolExecutor线程池前言：的实现原理

　　线程池是一个非常重要的知识点，是池化技术的典型应用。相信很多人都有使用线程池的经验，但是你们都知道线程池的实现原理吗？在本文中，我们将深入线程池源代码来寻找答案。

　　00-1010背景：随着计算机硬件的升级，我们的软件具备了多线程执行任务的能力。当我们在做多线程编程的时候，我们需要创建线程。如果程序并发性很高，我们会创建大量的线程，每个线程执行一个短任务后就结束了。这种频繁的线程创建会大大降低系统性能并增加服务器开销，因为创建和销毁线程都需要额外的消耗。

　　这时候我们可以借助池化技术来优化这个缺陷，线程池就诞生了。

　　池化技术的本质是，在高并发场景下，为了实现资源重用，减少资源创建和销毁的开销，如果并发数量少(资源一直占用系统内存，没有机会被使用)就没有明显的优势。

　　池化技术介绍：有什么时间池技术？池技术是一种编程技巧，在程序高并发时可以明显优化程序，减少频繁创建和销毁连接的开销。我们经常会接触到数据库连接池、线程池、对象池等池化技术。连接池技术的特点是在特定的池(内存)中维护一些高成本的资源，并指定其最小连接数、最大连接数、阻塞队列、溢出规则等配置。以便于统一管理。一般来说，它还附带一些支持功能，如监控和强制回收。

　　池化技术作为一种资源使用技术，典型的使用情形是：

　　当获取资源的成本高、请求资源的频率高、使用的资源总数低时，它面临性能问题，这涉及到处理时间延迟时的池化技术资源分类：。

　　系统调用的系统资源，如线程、进程、内存分配和网络通信的其他远程资源，如数据库连接和套接字连接。

　　00-1010线程池就是为了避免创建线程和销毁线程的额外开销而诞生的。因此，在我们定义并创建线程池之后，我们不需要自己创建线程，而是使用线程池调用来执行我们的任务。让我们看看如何定义和创建线程池。

　　00-1010你可以使用Executors创建线程池，它提供了一系列创建线程池的工厂方法，返回的线程池都实现了ExecutorService接口。

　　ExecutorService接口是Executor接口的子类接口，应用广泛。它提供了线程池生命周期管理的方法，并返回Future 对象.

　　也就是说，我们通过ExecutorService创建一个线程池，得到ExecutorService，通过ExecutorService执行异步任务(实现Runnable接口)。

　　Executors 可以创建一下几种类型的线程池：

　　NewCachedThreadPool创建一个可缓存的线程池。如果线程池中有太多的线程，多余的线程资源将在60秒后被回收。当任务书增加，线程不够的时候，就会产生新的线程。NewFixedThreadPool创建一个定长线程池，可以控制并发线程的最大数量，多余的线程会在队列中等待。NewScheduledThreadPool创建一个固定长度的线程池，它支持计划的和定期的任务执行。NewSingleThreadExecutor创建单线程线程池，只使用一个唯一的线程执行任务，可以保证任务按照提交的顺序完成。

　　00-1010在阿里巴巴的开发规范中规定线程池不允许由Executors创建，而是由ThreadPoolExecutor创建。

　　好处：写的同学可以更清楚线程池的运行规则，避免资源耗尽的风险。

　　ThreadPoolExecutor的七大参数：

　　(1)corePoolSize核心线程的数量。核心线程会一直保留，不会被破坏。

　　(2)maximumPoolSize最大线程数。当核心线程不能满足任务的需要时，系统会创建一个新的线程来执行任务。

　　(3)keepAliveTime生存时间，核心线程之外的线程空闲多长时间就会被销毁。

　　(4)timeUnit表示线程存活的时间单位。

　　(5)街区

　　ingQueue 阻塞队列

　　如果正在执行的任务超过了最大线程数，可以存放在队列中，当线程池中有空闲资源就可以从队列中取出任务继续执行。队列类型有如下几种类型：LinkedBlockingQueue ArrayBlockingQueue SynchronousQueue TransferQueue。(6)threadFactory 线程工厂，用来创建线程的，可以自定义线程，比如我们可以定义线程组名称，在jstack问题排查时，非常有帮助。

　　(7)rejectedExecutionHandler 拒绝策略,

　　当所有线程（最大线程数）都在忙，并且任务队列处于满任务的状态，则会执行拒绝策略。

　　JDK为我们提供了四种拒绝策略，我们必须都得熟悉

　　AbortPolicy: 丢弃任务，并抛出异常RejectedExecutionException。默认DiscardPolicy: 丢弃最新的任务，不抛异常。DiscardOldestPolicy: 扔掉排队时间最久的任务，也就是最旧的任务。CallerRuns: 由调用者（提交异步任务的线程）处理任务。

线程池的实现原理

想要实现一个线程池我们就需要关心ThreadPoolExecutor类，因为Executors创建线程池也是通过new ThreadPoolExecutor对象。

　　看一下ThreadPoolExecutor的类继承关系，可以看出为什么通过Executors创建的线程池返回结果是ExecutorService，因为ThreadPoolExecutor是ExecutorService接口的实现类，而Executors创建线程池本质也是创建的ThreadPoolExecutor 对象。

　　下面我们一起看一下ThreadPoolExecutor的源码，首先是ThreadPoolExecutor内定义的变量，常量：

 // 复合类型变量 是一个原子整数 控制状态（运行状态线程池活跃线程数量） private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); private static final int COUNT_BITS = Integer.SIZE - 3; // 低29位 private static final int CAPACITY   = (1 << COUNT_BITS) - 1; // 容量 // 运行状态存储在高位3位 private static final int RUNNING    = -1 << COUNT_BITS;  // 接受新任务，并处理队列任务 private static final int SHUTDOWN   =  0 << COUNT_BITS;  // 不接受新任务，但会处理队列任务 private static final int STOP       =  1 << COUNT_BITS;  // 不接受新任务，不会处理队列任务，中断正在处理的任务 private static final int TIDYING    =  2 << COUNT_BITS;  // 所有的任务已结束，活跃线程为0，线程过渡到TIDYING状 态，将会执行terminated()钩子方法 private static final int TERMINATED =  3 << COUNT_BITS;  // terminated()方法已经完成 // 设置 ctl 参数方法 private static int runStateOf(int c)     { return c & ~CAPACITY; } private static int workerCountOf(int c) { return c & CAPACITY; } private static int ctlOf(int rs, int wc) { return rs wc; }    /**     * 阻塞队列     */    private final BlockingQueue<Runnable> workQueue;    /**     * Lock 锁.     */    private final ReentrantLock mainLock = new ReentrantLock();    /**     * 工人们     */    private final HashSet<Worker> workers = new HashSet<Worker>();    /**     * 等待条件支持等待终止     */    private final Condition termination = mainLock.newCondition();    /**     * 最大的池大小.     */    private int largestPoolSize;    /**     * 完成任务数     */    private long completedTaskCount;    /**     * 线程工厂     */    private volatile ThreadFactory threadFactory;    /**     * 拒绝策略     */    private volatile RejectedExecutionHandler handler;    /**     * 存活时间     */    private volatile long keepAliveTime;    /**     * 允许核心线程数     */    private volatile boolean allowCoreThreadTimeOut;    /**     * 核心线程数     */    private volatile int corePoolSize;    /**     * 最大线程数     */    private volatile int maximumPoolSize;    /**     * 默认拒绝策略     */    private static final RejectedExecutionHandler defaultHandler =        new AbortPolicy();    /**     * shutdown and shutdownNow权限     */    private static final RuntimePermission shutdownPerm =        new RuntimePermission("modifyThread");

构造器,,支持最少五种参数，最大七中参数的四种构造器：

    public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue<Runnable> workQueue) {        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,             Executors.defaultThreadFactory(), defaultHandler);   }    public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue<Runnable> workQueue,                              ThreadFactory threadFactory) {        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,             threadFactory, defaultHandler);   }    public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue<Runnable> workQueue,                              RejectedExecutionHandler handler) {        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,             Executors.defaultThreadFactory(), handler);   }    public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue<Runnable> workQueue,                              ThreadFactory threadFactory,                              RejectedExecutionHandler handler) {        if (corePoolSize < 0            maximumPoolSize <= 0            maximumPoolSize < corePoolSize            keepAliveTime < 0)            throw new IllegalArgumentException();        if (workQueue == null threadFactory == null handler == null)            throw new NullPointerException();        this.corePoolSize = corePoolSize;        this.maximumPoolSize = maximumPoolSize;        this.workQueue = workQueue;        this.keepAliveTime = unit.toNanos(keepAliveTime);        this.threadFactory = threadFactory;        this.handler = handler;   }

工人，线程池中执行任务的，线程池就是通过这些工人进行工作的，有核心员工（核心线程）和临时工（人手不够的时候，临时创建的，如果空闲时间厂，就会被裁员），

    private final class Worker        extends AbstractQueuedSynchronizer        implements Runnable   {        private static final long serialVersionUID = 6138294804551838833L;        // 工人的本质就是个线程        final Thread thread;        // 第一件工作任务        Runnable firstTask;      volatile long completedTasks;        /**         * 构造器         */        Worker(Runnable firstTask) {            setState(-1); // inhibit interrupts until runWorker            this.firstTask = firstTask;            this.thread = getThreadFactory().newThread(this);       }        /** 工作 */        public void run() {            runWorker(this);       }        protected boolean isHeldExclusively() {            return getState() != 0;       }        protected boolean tryAcquire(int unused) {            if (compareAndSetState(0, 1)) {                setExclusiveOwnerThread(Thread.currentThread());                return true;           }            return false;       }        protected boolean tryRelease(int unused) {            setExclusiveOwnerThread(null);            setState(0);            return true;       }        public void lock()       { acquire(1); }        public boolean tryLock() { return tryAcquire(1); }        public void unlock()     { release(1); }        public boolean isLocked() { return isHeldExclusively(); }        void interruptIfStarted() {            Thread t;            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {                try {                    t.interrupt();               } catch (SecurityException ignore) {               }           }       }   }

核心方法，通过线程池执行任务（这也是线程池的运行原理）：

　　检验任务获取当前线程池状态判断上班工人数量是否小于核心员工数如果小于则招人，安排工作不小于则判断等候区任务是否排满如果没有排满则任务排入等候区如果排满，看是否允许招人，允许招人则招临时工如果都不行，该线程池无法接收新任务，开始按老板约定的拒绝策略，执行拒绝策略

    public void execute(Runnable command) {        if (command == null)            throw new NullPointerException();        int c = ctl.get();        if (workerCountOf(c) < corePoolSize) {            if (addWorker(command, true))                return;            c = ctl.get();       }        if (isRunning(c) && workQueue.offer(command)) {            int recheck = ctl.get();            if (! isRunning(recheck) && remove(command))                reject(command);            else if (workerCountOf(recheck) == 0)                addWorker(null, false);       }        else if (!addWorker(command, false))            reject(command);   }

submit（）方法是其抽象父类定义的，这里我们就可以明显看到submit与execute的区别，通过submit调用，我们会创建RunnableFuture，并且会返回Future，这里我们可以将返回值类型，告知submit方法，它就会通过泛型约束返回值。

public abstract class AbstractExecutorService implements ExecutorService { public Future<?> submit(Runnable task) {        if (task == null) throw new NullPointerException();        RunnableFuture<Void> ftask = newTaskFor(task, null);        execute(ftask);        return ftask;   }    public <T>&nbs      

	  




	  
	  
	  
	  
	  
        
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。