（二）并发编程之线程池

如果是Executors创建的FixedThreadPool、CachedThreadPool（队列长度为Integer.MAX_VALUE）顺序会改变吗？

来看看代码

package ThreadPoll;

import java.util.concurrent.*;

public class Test {


    public static void main(String[] args) throws InterruptedException {

        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                2,
                Integer.MAX_VALUE,
                1,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>());
        while (true){
            System.out.println("线程池大小"+poolExecutor.getPoolSize());
            System.out.println("队列大小"+poolExecutor.getQueue().size());
            TimeUnit.MILLISECONDS.sleep(100);
            poolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("submit");
                        TimeUnit.HOURS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

这里我自己定义了线程池，但队列长度还是使用的默认（Integer.MAX_VALUE）。
运行结果如下：
使用jconsole查看jvm内存使用情况。内存会不断的最大，队列大小也在不断的增加。

程序刚刚启动核心线程会被创建吗？

程序刚刚启动线程是不会被创建的，只有向线程池提交了线程，线程才会创建，核心线程会一直存在。
上栗子：

package ThreadPoll;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestStart {

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                2,
                5,
                5,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3));
        TimeUnit.SECONDS.sleep(20);
        System.out.println("----");
        for (int i = 0;i<9;i++){
            poolExecutor.submit(() -> {
                System.out.println("submit");
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }
}

结果是这样的：
线程启动时没有直接创建好核心线程，而是等待提交的时候才去创建的核心线程，之后就一直保持存活。而非核心线程在使用之后，存活时间到了就被销毁了。因为这里队列的大小设置为了3，提交时会出现队列爆满的情况，就会执行拒绝策略。

线程池的shutdownNow()和shutdown()有啥区别吗？

shutdownNow()：
执行该方法，线程池的状态立刻变成STOP状态，并试图停止所有正在执行的线程，不再处理还在池队列中等待的任务，当然，它会返回那些未执行的任务。 它试图终止线程的方法是通过调用Thread.interrupt()方法来实现的，但是大家知道，这种方法的作用有限，如果线程中没有sleep 、wait、Condition、定时锁等应用, interrupt()方法是无法中断当前的线程的。所以，ShutdownNow()并不代表线程池就一定立即就能退出，它可能必须要等待所有正在执行的任务都执行完成了才能退出。返回值是已经提交而未被执行的线程列表，这给这些线程一个重新执行的机会。

shutdown()：
当线程池调用该方法时,线程池的状态则立刻变成SHUTDOWN状态。此时，则不能再往线程池中添加任何任务，否则将会抛出RejectedExecutionException异常。但是，此时线程池不会立刻退出，直到添加到线程池中的任务都已经处理完成，才会退出。

package ThreadPoll;

import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestStopN {

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                2,
                5,
                5,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3));
        TimeUnit.SECONDS.sleep(2);
        poolExecutor.submit(() -> {
                System.out.println("submit");
                try {
                    for (int i = 0;;i++){
                        TimeUnit.SECONDS.sleep(1);
                        System.out.println(i);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        });
        poolExecutor.shutdownNow();
    }

}

代码中有sleep，会响应中断。要是没有就不会停止。

ThreadPoolExecutor 提供了三个方法，都是protected修饰的。

beforeExecute() 线程执行之前调用
afterExecute() 线程执行之后调用
terminaerd()　　线程池退出时候调用