线程池详解

为什么要用线程池？

线程池中的线程可以重复利用，避免了重复创建线程造成的资源开销

什么时候可以用线程池？

1. 线程的执行时间比较短
2. 处理的任务比较多

线程的生命状态

线程池参数说明

corePoorSize：核心线程数

maximumPoorSize：最大线程数--核心线程数+非核心线程数

keepAliveTime：非核心线程允许空闲时间，超过则线程销毁

unit：keepAliveTime单位

workQueue：保存任务的阻塞队列

threadFactory：创建线程的工厂

hander：线程池饱和的处理方式（拒绝策略）

 线程池执行步骤

1.  如果运行的线程少于核心线程，会尝试去开启一个新的核心线程（addWorker），如果有空间的核心线程，也不会去使用，而是去创建一个新的核心线程，直到核心线程创建满。核心线程创建满了，线程去队列中取任务。
2. 如果运行的线程数等于核心线程数，任务则进入队列等待核心线程调用。
3. 如果队列已满，则去创建非核心线程。
4. 如果非核心线程也饱和了，则进入拒绝策略

 拒绝策略

1. AbortPolicy：抛出异常（默认）
2. CallerRunsPolicy：提交任务的线程自己执行
3. DisCardOldestPolicy：把老的任务丢掉
4. DiscardPolicy：什么都没干，直接丢掉任务

线程池运行状态

1. Running：接收新任务，对已添加的任务进行处理
2. ShutDown：不接收，可对已有的线程进行处理
3. Stop：不接收，不处理
4. Tidying：线程池终止前的状态，可以做一些处理
5. Terminated：线程终止

线程运行状态 

1.调用wait和notify，线程必须持有对象锁才能生效，否则会抛出异常

2.yield：放弃CPU使用权，因为CPU调用哪个线程具有随机性，有可能还会调用原来的线程

创建线程的四种方法

继承Thread类

public class ThreadTest extends Thread {
    @Override
    public void run() {
        //业务代码
    }
}

public static void main(String[] arg) {
    ThreadTest thread = new ThreadTest();
    thread.start();
}

实现Runnable接口

public class RunnableTest implements Runnable{
    @Override
    public void run() {
        //业务代码
    }
}

public static void main(String[] arg) {
    Thread thread = new Thread(new RunnableTest());
    thread.start();
}

实现Callable接口

public class CallableTest implements Callable<String> {

        @Override
        public String call() throws Exception {
            //业务代码
            System.out.println("执行业务3");
            return "callableTest";
        }
    }

public static void main(String[] arg) {
        CallableTest thread = new CallableTest();
        FutureTask<String> task = new FutureTask<>(thread);
        new Thread(task).start();

        try {
            System.out.println(task.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

    }

用线程池实现

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(5));
        for (int i = 0 ; i < 10 ;i++) {
            int k = i;
            threadPoolExecutor.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程" + k);
                }
            });
        }

定时线程池

ScheduledThreadPoorExecutor

没有非核心线程，用来处理延时或者定时任务

使用场景：

分布式锁----redis锁续命

发送心跳----注册中心

三种实现方法

scheduled：延时

scheduleAtFixedRate：周期执行，当任务执行时间大于周期执行时间，会出现任务堆积

scheduledWithFixedDelay：可以解决任务堆积，会等任务执行完再延时周期时间执行

 以scheduledWithFixedDelay为例，周期执行过程：

public static void main(String[] args) throws Exception {
        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(5);

scheduledThreadPoolExecutor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程执行");
            }
        }, 1, 2 , TimeUnit.SECONDS);
}

Timer与ScheduledThreadPoorExecutor功能类似

Timer：如果有一个任务抛出异常，其它任务也不能执行

new Timer时，只new一个Thread，是单线程的，所以Thread挂了，其它任务也不能执行了。

ThreadPoorExecutor与ScheduledThreadPoorExecutor不同：

1.ScheduledThreadPoorExecutor用到的队列与ThreadPoorExecutor不同，采用DelayQueue，内部封装PriorityQueue，可以根据时间排序，使用到了堆结构，最小根堆。

2.任务优先丢到队列中，而不是去创建核心线程