关于高并发与多线程中的线程池

定义

线程是稀缺资源，它的创建与销毁是一个相对偏重且耗资源的操作，而Java线程依赖于内核线程,创建线程需要进行操作系统状态切换,为避免资源过度消耗需要设法重用线程执行多个任务。线程池就是一个线程缓存,负责对线程进行统一分配、调优与监控。

什么时候使用线程池：

• 单个任务处理时间比较短
• 需要处理的任务数比较大

线程池的优势：

• 重用存在的线程，减少线程创建，消亡的开销，提高性能
• 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
• 提高线程的可管理性，可统一分配，调优和监控。

线程池的创建方式

JavaJUC包下的Executors 提供了创建线程池的四种方式及底层参数（四种线程的创建方式其底层都是使用ThreadPoolExecutor这个类，根据参数的不同来定义的，下面会给出相关参数的说明）

newCachedThreadPool

定义及作用

创建一个可根据需要创建新线程的线程池，如果线程池中有可用线程（可用指线程存在且空闲），如果没有则创建一个新的线程去执行，通常用于执行时间比较短的异步任务

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,//此核心线程数corePoolSize为0，maximumPoolSize接近无限大
                                      60L, TimeUnit.SECONDS,//keepAliveTime存活时间为 60s，时间到自动回收
                                      new SynchronousQueue<Runnable>());//使用的是同步阻塞队列
    }

用法实例

//定义一个线程类
class RunnableThread implements Runnable{
    private int i=0;
    public RunnableThread(int i) {
        this.i = i;
    }
     public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"执行了第"+i+"个任务！");
        }
    }
//创建10个任务
   ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            executorService.execute(new RunnableThread(i));

        }

可以看到一秒后一下执行了10个任务

newScheduledThreadPool

定义及作用

创建一个支持周期执行，可做定时任务的线程池，主要用于周期性的执行任务的场景

  public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,//maximumPoolSize接近无限大，keepAliveTime存活时间为 0纳秒，线程不会被回收
              new DelayedWorkQueue());//采用延迟队列，提交的任务按照执行时间排序到队列中
    }

用法实例

  //schedule 是ScheduledExecutorService特有的方法
ScheduledExecutorService  executorService = Executors.newScheduledThreadPool(6);
            executorService.schedule(new RunnableThread(1),6L,TimeUnit.SECONDS);
            executorService.schedule(new RunnableThread(2),5L,TimeUnit.SECONDS);
            executorService.schedule(new RunnableThread(3),4L,TimeUnit.SECONDS);
            executorService.schedule(new RunnableThread(4),3L,TimeUnit.SECONDS);
            executorService.schedule(new RunnableThread(5),2L,TimeUnit.SECONDS);

可以看到按预先设置的延时去执行任务，需要做定时任务的可以使用此线程去实现

newFixedThreadPool

定义及作用

根据需要创建一个可固定线程数的线程池，任务较多时入队等待，适用于任务数固定，平稳的场景下，就是确定并发压力的情况下，去创建指定的线程数

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,//核心线程数等于最大线程数
                                      0L, TimeUnit.MILLISECONDS,//纳秒
                                      new LinkedBlockingQueue<Runnable>()); //阻塞队列，任务量来的时候无可用线程时，入队等待
    }

用法实例

   ExecutorService  executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 6; i++) {
            executorService.execute(new RunnableThread(i));
        }

可以看到第一秒三个线程执行一次，第2秒这三个线程又重复执行了，没有创建新的线程

newSingleThreadExector

定义及作用

创建一个只有单个线程的线程池，使用唯一工作线程去执行任务，保证任务的有序执行，适用于要求任务有序进行的情况下，和newFixedThreadPool定义一样，只是线程数只有一个

 public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }

用法实例

   ExecutorService  executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            executorService.execute(new RunnableThread(i));
        }

可以看到任务是一秒钟执行一个，且是有序进行

以上是Executors所提供的的四种线程池的创建，从上清楚的看到其底层是使用ThreadPoolExecutor根据不同的参数来确定的。下面主要是以这个类来对线程池底层原理做分析。

ThreadPoolExecutor

//构造方法
public ThreadPoolExecutor(int corePoolSize,  //核心线程数
                              int maximumPoolSize,  //最大线程数
                              long keepAliveTime,  //存活时间
                              TimeUnit unit,  //时间单位
                              BlockingQueue<Runnable> workQueue,  //使用队列类型,任务可以储存在任务队列中等待被执行，执行的是FIFIO原则（先进先出
                              ThreadFactory threadFactory,  //就是创建线程的线程工，可以通过自己自定义的方式去创建一个线程
                              RejectedExecutionHandler handler)//是一种拒绝策略，我们可以在任务满了后，根据采用的策略拒绝执行某些任务，java提供了四种执行策略:
   			    // AbortPolicy：中断抛出异常
    			//DiscardPolicy：默默丢弃任务，不进行任何通知
    			//DiscardOldestPolicy：丢弃掉在队列中存在时间最久的任务
    			//CallerRunsPolicy：让提交任务的线程去执行任务(对比前三种比较友好一丢丢)

线程的执行原理（结合源码来看的话会更明白）

在实际项目开发中也是推荐使用手动创建线程池的方式，而不用默认方式，关于这点在《阿里巴巴开发规范》中是这样描述的：

创建一个自定义线程池，根据并发量和具体的任务需求去创建线程池

 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20, 0L, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<>(10));
        for (int i = 0; i < 100; i++) {
            threadPoolExecutor.execute(new RunnableThread(i)
            );
        }

execute源码：关于源码这部分说明，后面会做补充

   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); //采用拒绝策略

    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

关于线程池的基本使用和原理就先到这了，欢迎各位指出不足，共同学习！！