Java基础线程池简析-CFANZ编程社区

前言

多线程编程是一个难点，好多面试官都会问。虽然平时用到多线程编程的地方比较少，掌握基本的用法事半功倍。

合理使用多线程的好处

1.降低资源消耗
2.提高响应速度
3.提高线程的可管理性

频繁的创建的Thread 类比较消耗系统资源，比较好的做法就是使用线程池来管理线程。

线程池的实现原理

当向线程池提交一个任务之后，线程池是如何处理这个任务的呢？

Java基础线程池简析_工作线程

1.判断核心线程池是否已满，未满则创建新线程，如果已满则执行下个步骤
2.线程池判断工作队列是否已满，未满则将任务存储在队列里，否则执行下个步骤
3.线程池中普通线程是否已满，未满则创建线程执行任务，否则交给饱和策略处理这个任务。

Java基础线程池简析_线程池_02

ThreadPoolExecutor 执行execute方法分四步：

1.如果当前运行的线程少于corePoolSize,则创建新线程来执行任务【执行需要获取全局锁】
2.如果执行的线程大于等于corePoolSize，则将当前线程放入Blockingqueue。
3.如果无法将任务加入BlockingQueue中，则创建新线程来执行任务【执行需要获取全局锁】
4.如果创建的新线程使当前运行的线程总数超过maxnumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()

源码展示：

ThreadPoolExecutor.execute(Runnable command) 类

 /**
     * Executes the given task sometime in the future.  The task
     * may execute in a new thread or in an existing pooled thread.
     *
     * If the task cannot be submitted for execution, either because this
     * executor has been shutdown or because its capacity has been reached,
     * the task is handled by the current {@code RejectedExecutionHandler}.
     *
     * @param command the task to execute
     * @throws RejectedExecutionException at discretion of
     *         {@code RejectedExecutionHandler}, if the task
     *         cannot be accepted for execution
     * @throws NullPointerException if {@code command} is null
     */
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        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);
    }

tips：这里引入一个Worker对象，该对象是线程池创建时，将Thread 封装成worker工作线程。
而，工作线程会循环获取BlockingQueue中的线程来执行。

Java基础线程池简析_阻塞队列_03

线程池的使用

1.创建

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {

参数依次代表的意思：

1.定义核心线程数
2线程池最大线程数量
3.空闲线程存货的时间
4.时间单位
5.线程池缓冲队列，
6自定义线程池创建工厂
7.线程池饱和后的处理策略

tips：实现阻塞队列的几个类分别是

ArrayBlockingQueue：基于数组结构的有界阻塞队列，FIFO对入队元素进行排序

LinkedBlockingQueue：基于链表数据结构的阻塞队列，吞吐率高于ArrayBlockingQueue队列。

SynchronousQueue: 一个不存储元素的阻塞队列，插入必须等待着另一个线程调用移除操作，否则插入操作一直处于阻塞状态。吞吐量高于LinkedBlockingQueue

priorityBlockingQueue:一个具有优先级的无线阻塞队列