线程池

Callable接口

相比于runnable接口而言，callable可以抛出异常，并且返回返回值

callable接口基本使用

class Task implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread().getName());
        TimeUnit.SECONDS.sleep(5);
        return "aaa";
    }
}

public class ThreadPoolTest {

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

        FutureTask futureTask = new FutureTask(new Task());

        Thread thread = new Thread(futureTask);

        thread.start();

        // futureTask获取不到线程的返回值结果，会一直堵塞线程
        System.out.println(futureTask.get());

    }
}

为什么要使用线程池

我们知道创建线程需要时间和空间。如果使用一次就不在使用，会等待 young GC 回收。当有大量的异步任务时，创建大量线程对象，消耗了时间和堆空间，会导致eden区 更早触发young gc，进一步降低效率。

优点：

降低资源消耗。通过重复利用己创建的线程降低线程创建和销毁造成的消耗。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

创建线程的四种方式

1、继承Thread

2、实现Runnable

3、实现Callable

4、使用线程池

线程池七大参数

我们以Executors为例

Executors为线程工具类，使用时可以便捷的创建线程。

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

        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        System.out.println("固定线程的线程池");
        for (int i = 0; i < 5; i++) {
            fixedThreadPool.execute(()->{
                System.out.println(Thread.currentThread().getName()+" "+ fixedThreadPool.getClass().getName());
            });
        }

        System.out.println("---------------------------");

        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        System.out.println("单一线程的线程池");
        for (int i = 0; i < 5; i++) {
            singleThreadExecutor.execute(()->{
                System.out.println(Thread.currentThread().getName()+" "+ singleThreadExecutor.getClass().getName());
            });
        }

        System.out.println("---------------------------");

        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        System.out.println("缓存线程的线程池");
        for (int i = 0; i < 5; i++) {
            singleThreadExecutor.execute(()->{
                System.out.println(Thread.currentThread().getName()+" "+ cachedThreadPool.getClass().getName());
            });
        }

    }

1、Executors.newFixedThreadPool(3);

固定大小的线程池

2、Executors.newSingleThreadExecutor();

单一线程的线程池

3、Executors.newCachedThreadPool();

可缓存线程的线程池

线程池七大参数

1、corePoolSize 核心线程数（常驻线程）

2、maximumPoolSize 最大线程数 （线程池容纳的最大线程，当堵塞队列和常驻线程都没有空间时，会开启最大线程数-核心线程数得到的线程）

3、keepAliveTime 最大线程数-核心线程数得到的线程 存活的时间

4、TimeUnit 时间单元

5、BlockingQueue 存放线程执行任务的堵塞队列（该队列是线程安全的，当线程池中线程没时间处理任务时，任务进入堵塞队列）

6、ThreadFactory 生产线程的工厂

7、RejectedExecutionHandler 拒绝执行的处理器策略，当maximumPoolSize对应的线程都在执行任务，堵塞队列也满了，对后来的线程的拒绝执行的处理策略

**注意：首次有任务来的时候，创建的是核心线程，该线程不会关闭。
所以上图中第一次 创建核心线程执行任务，第二次创建非核心线程执行任务**

不能使用Executors创建线程

Executors创建的线程，底层都是通过ThreadPoolExecutor创建的，并且使用的是LinkedBlockingQueue队列，默认最大Integer.MAX_VALUE。这意味这，除非没有内存了，不然队列永远满不了。在高并发下，内存中会囤积大量的异步任务，容易发生OOM，线程的执行效率也会变低。

线程池的4种拒绝策略

等待队列也已经排满了，再也塞不下新任务了同时，线程池中的max线程也达到了，无法继续为新任务服务。

这时候我们就需要拒绝策略机制合理的处理这个问题。

JDK拒绝策略：

1、AbortPolicy（默认）：直接抛出 RejectedExecutionException异常阻止系统正常运知。

2、CallerRunsPolicy："调用者运行"一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。

3、DiscardOldestPolicy：抛弃队列中等待最久的任务，然后把当前任务加入队列中尝试再次提交当前任务。

4、DiscardPolicy：直接丢弃任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种方案。

手写一个线程池

注意：开发中常见的应该是scheduledThreadPoolExecutor+ timerTask

class Task extends TimerTask{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() +"执行任务");
    }
}
public static void main(String[] args)throws Exception {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(5),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());


        // 核心线程 和  blockingQueue 已满会创建 剩下的线程执行
        for (int i = 0; i < 8 ; i++) {
            threadPoolExecutor.execute(new Task());
        }
    }

**核心线程 和 blockingQueue 已满会创建 剩下的线程执行。
如果max线程 和 blockingQueue 已满会 还有任务要处理，该任务直接丢弃**

合理线程池线程数

CPU密集型

CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。

CPU密集任务只有在真正的多核CPU上才可能得到加速(通过多线程),
而在单核CPU上，无论你开几个模拟的多线程该任务都不可能得到加速，因为CPU总的运算能力就那些。

CPU密集型任务配置尽可能少的线程数量：

一般公式：（CPU核数+1）个线程的线程池
例如：8核+8 = 16

lO密集型

由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如CPU核数 * 2。

IO密集型，即该任务需要大量的IO，即大量的阻塞。

在单线程上运行IO密集型的任务会导致浪费大量的CPU运算能力浪费在等待。

所以在IO密集型任务中使用多线程可以大大的加速程序运行，即使在单核CPU上，这种加速主要就是利用了被浪费掉的阻塞时间。

IO密集型时，大部分线程都阻塞，故需要多配置线程数：

**参考公式：CPU核数/ (1-阻塞系数)
阻塞系数在0.8~0.9之间
比如8核CPU：8/(1-0.9)=80个线程数**