线程池

线程池的结构

线程池：
其实就是一个容纳多个线程的容器，其中的线程可以反复的使用，省去了频繁创建的线程对象的操作，无需反复创建线程而消耗 过多的资源，有时花在线程创建的和销毁的时间比真正执行的时间还要长通常我们使用线程池，都是通过Executors 工厂方法来创建一个线程池。
这张图可以完美解释是线程池的工作原理：

线程池的参数是什么意思
比如去火车站买票，有10个售票窗口，但只有5个对外开放，那么这5个窗口称之为核心线程数，而最大线程数，就是那10个窗口， 如果5个窗口被占用，那么后来的人就必须再后面排对，但是售票厅的人越来越多，已经人满为患，就类似于线程的队列已经满了，火车站长下令，把剩下的5个窗口也打开，也就是目前已经有10个窗口同时运行，后来又来了一批人，10个窗口也处理不了，而且售票厅的人已经满了，这时候站长下令封锁入口不允许其他人再进来，这就是线程异的时间指着允许售票员休息的最长时间，以此限制常处理策略，而线程存活售票员的偷懒。

ThreadPoolExecutor threadPoolExecutor 
= new ThreadPoolExecutor(int corePoolSize,//核心线程数
                              int maximumPoolSize,//最大线程数
                              long keepAliveTime,//闲置线程存活时间
                              TimeUnit unit,//时间单位
                              BlockingQueue<Runnable> workQueue,//线程队列
                              ThreadFactory threadFactory,//线程工厂
                              RejectedExecutionHandler handler)// 队列已满抛出异常

corePoolSize：
核心线程数：默认情况下不会被销毁，一直存活下去，即使闲置状态也不会受keepAliveTime限制
maximumPoolSize：
线程池所能容纳的最大线程数，超过这个数的线程将会被阻塞，当任务队列为没有的设置大小的 BlockingQueue这个值为默认值；

keepAliveTime：
非核心线程的的闲置超时时间，超过这个时间就会被回收
unit：
指定keepAliveTime的单位，
workQueue：
线程池中常用的两种队列：
LinkedBlocking,ArrayBlockQueue.阻塞队列
ThreadFactory：
线程工厂，提供创建新线程的功能，ThreadFactory是一个接口，只有一个方法

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

通过线程工厂可以对线程的一些属性进行定制：

RejectedExecutionHandler：
也是一个接口，只有一个方法

public interface RejectedExecutionHandler {
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

当线程池中的 资源已经全部使用，添加线程被拒绝时，会调用 RejectedExecutionHandler的rejectedExecution方法。

Executor是一个顶层接口，在它里面只声明了一个方法execute(Runnable)，返回值为void，参数为Runnable类型，从字面意思可以理解，就是用来执行传进去的任务的；
　　然后ExecutorService接口继承了Executor接口，并声明了一些方法：submit、invokeAll、invokeAny以及shutDown等；
　　抽象类AbstractExecutorService实现了ExecutorService接口，基本实现了ExecutorService中声明的所有方法；
　　然后ThreadPoolExecutor继承了类AbstractExecutorService。
　　在ThreadPoolExecutor类中有几个非常重要的方法：
1、execute()
2、submit()
3、shutdown()
4、shutdownNow()
execute()方法实际上是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，通过这个方法可以向线程池提交一个任务，交由线程池去执行。
　　submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并没有对其进行重写，这个方法也是用来向线程池提交任务的，但是它和execute()方法不同，它能够返回任务执行的结果，去看submit()方法的实现，会发现它实际上还是调用的execute()方法，只不过它利用了Future来获取任务执行结果
　　shutdown()和shutdownNow()是用来关闭线程池的。
先看看成员变量：
参数runstate

RUNNING：接收新任务和处理队列任务
SHUTDOWN:不接收新任务，但处理队列里的任务
STOP:不接收新任务，也不处理队列任务何中断正在执行的任务
TERMINATED：和STOP一样

以下是runstate状态的转换过程：
RUNING->SHUTDOWN 调用shutdown()
(RUNNING or SHUTDOWN) ->STOP 调用shutdownnow()
SHUTDOWN->TERMINATED 当队列和线程池都是空的
STOP->TERMINATED 当线程池是空的

线程池中的重要参数：
workQueue：
该成员变量是个阻塞队列，主要用于存储需要执行任务和把任务转交给worker线程
mainLock：
用来对成员变量pooSize，corePoolSize，maximumPoolSize，runState、workers修改时候同步
termination：
用来支持waitTemination
workers：
集合包含的所有worker线程在线程池，只能通过mainLock访问
keepAliveTime：
设置空闲线程等待多时毫秒被回收
allowCoreThreadTimeOut：
设置核心线程空闲时候是否被回收，默认false
corePoolSize：核心线程数，需要使用mainLock同步更新
maximumPoolSize：最大线程数，需要使用mainLock同步更新
poolSize：当前线程数，需要使用mainLock同步更新
handler：当线程池饱和或者shutdown时候被执行
threadFactory： 线程工厂
largestPoolSize： 最大线程数，这个参数的存在似乎是为了更正并发情况下poolSize的修改
completedTaskCount：获取已完成的任务数量
defaultHandler：默认的拒绝处理器
addWorker失败的话可能会导致线程池关闭

execute分三步进行:
① 当前线程池中线程数目小于corePoolSize，直接new一个thread；
② 当先线程池数据大于corePoolSize，则放入workQueue中；
③ 如果workQueue满了且线程池中线程数小于maximumPoolSize，则new一个thread。

（1）、首先查看线程池中的线程数量是否小于我们指定的核心线程的数目，如果是就尝试创建新的线程，把command作为他第一个任务，并将其加入到线程池中但是我们在判断了线程池的数量合法后，调用addWorker(command, true)把线程加入到线程池中时，是多线程并发的，可能会导致加入失败。如果加入成功，则直接返回，若假如失败，则重新获取clt，因为此时clt必发生了变化，否则不会失败，继续往下执行
（2）、通过isRunning© 判断如果线程池还在运行，那我们就尝试把当前的command加入到阻塞队列中。加入的过程也是并发的，也可能会出现失败。如果失败在继续执行（3）。加入阻塞队列成功后我们要重新在检查一遍，防止在加入的过程中线程时关闭了或者线程池中没有线程了，全部因为空闲时间超过了我们指定的alivetime被回收了。如果是线程池已经不再是RUNNING状态，则用我们的拒绝策略去丢弃它（2.1）。如果是线程池没有了线程，那我们新建一个空线程，让他去阻塞队列中去获取任务执行（2.2）。
（3）如果上面的两步都没有执行成功，那我们此时就需要使用我们指定的最大线程池，来处理它，但是此时也是可能失败的，可能有多个线程执行么，如果失败，就用拒绝策略丢弃该线程。

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        //（1）
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //（2）
        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);
        }//（3）
        else if (!addWorker(command, false))
            reject(command);
    }

addworker

 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);
                //core true代表是往核心线程池中增加线程 false代表往最大线程池中增加线程
                //线程数超标，不能再添加了，直接返回
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                    //CAS修改clt的值+1，在线程池中为将要添加的线程流出空间，成功退出cas循环，失败继续
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                 //如果线程池的状态发生了变化回到retry外层循环
                if (runStateOf(c) != rs)
                    continue retry;
            }
        //新建线程，并加入到线程池workers中。
        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            final ReentrantLock mainLock = this.mainLock;
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                 //细化锁的力度，防止临界区过大，浪费时间
                mainLock.lock();
                try {
                    int c = ctl.get();
                    int rs = runStateOf(c);
                    //判断线程池的状态
                    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();
                        修正largestPoolSize的值
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                //线程添加线程池成功，则开启新创建的线程
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
             //线程添加线程池失败或者线程start失败，则需要调用addWorkerFailed函数，如果添加成功则需要移除，并回复clt的值
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

线程池:JDK1.5之后提供的
java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
Executors类中的静态方法:
static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
参数:
int nThreads:创建线程池中包含的线程数量
返回值:
ExecutorService接口,返回的是ExecutorService接口的实现类对象,我们可以使用ExecutorService接口接收(面向接口编程)
java.util.concurrent.ExecutorService:线程池接口
用来从线程池中获取线程,调用start方法,执行线程任务
submit(Runnable task) 提交一个 Runnable 任务用于执行
关闭/销毁线程池的方法
void shutdown()
线程池的使用步骤:
1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
2.创建一个类,实现Runnable接口,重写run方法,设置线程任务
3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
4.调用ExecutorService中的方法shutdown销毁线程池(不建议执行)

 public class pool  {
        public static void main(String[] args) {
            //1.使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池
            ExecutorService threadPool = Executors.newFixedThreadPool(2);
            //3.调用ExecutorService中的方法submit,传递线程任务(实现类),开启线程,执行run方法
            threadPool.submit(new Runable());//pool-1-thread-1
            //线程池会一直开启,使用完了线程,会自动把线程归还给线程池,线程可以继续使用
            threadPool.submit(new Runable());//pool-1-thread-1
            threadPool.submit(new Runable());//pool-1-thread-1
    
            threadPool.shutdown();//关闭线程池
           /* threadPool.submit(new Runable());
            threadPool.submit(new Runable());*/
        }
    }
    
    
    public class Runable implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    }

=============================================================================
四种常见线程池的创建：
1、可缓存：
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活收回空闲线程，若无可回收，则创建新线程
线程池为无限大，当执行第二个任务时已经完成第一个任务线程，会复用执行第一个任务线程。

 ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 100; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
        executorService.shutdown();

2、定长
创建一个定长线程池，可以控制线程最大并发数，超出的线程会在队列中等待，定的是核心线程数的长度

 ExecutorService executorService = Executors.newFixedThreadPool(3);
 for (int i = 0; i < 100; i++) {
     executorService.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName());
           try {
            Thread.sleep(2000);
            } catch (InterruptedException e) {
            e.printStackTrace();
           }
       }
   });
 }
  executorService.shutdown();

因为线程池大小为3，每次输出3个输出三个线程ID
3、定时
创建一个定时线程池，支持定时即周期性任务，延迟执行。

ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3);
    for (int i = 0; i < 100; i++) {
       scheduledExecutorService.schedule(new Runnable() {
           @Override
           public void run() {
               System.out.println(Thread.currentThread().getName());
           }
       },3,TimeUnit.SECONDS);
    }
    scheduledExecutorService.shutdown();

表示延时3秒执行
4、单利
创建一个单线程线程池，他只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序（IFO, LIFO, 优先级)执行

ExecutorService executorService = Executors.newSingleThreadExecutor();
    for (int i = 0; i < 100; i++) {
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
    }
    executorService.shutdown();