面试系列----谈谈线程池的使用

面试系列----谈谈线程池的使用

0.什么是线程池

线程池主要就是控制线程的数量，处理过程中将任务加到队列中，然后在线程创建后启动这些任务，如果线程超过最大数量，超出数量的线程排队等候，等其他线程执行完毕以后，在从队列中取出任务来执行。

他的主要特点就是：线程复用，管理线程，控制最大并发数。

使用线程池的好处：

第一：降低资源消耗，通过重复利用自己创建的线程降低线程创建和销毁造成的消耗。

第二:：提高响应速度.当任务到达时,任务可以不需要等到线程和粗昂就爱你就能立即执行.

第三：提高线程的可管理性.线程是稀缺资源,如果无限的创阿金,不仅会消耗资源,还会较低系统的稳定性,使用线程池可以进行统一分配,调优和监控.

1.线程池的使用

Java中的线程池是通过Executor框架实现的，该框架中用到了Executor,Executors,ExecutorService,ThreadPoolExecutor这几个类。

线程池有几个常见的实现方法Executors.newFixedThreadPool(5)、Executors.newSingleThreadExecutor()、Executors.newCachedThreadPool()；

下面是线程池几个实现类的基本使用：

public class MyThreadPoolDemo {

    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);//执行一个长期的任务,性能好很多
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();//一个任务一个线程执行的任务场景
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();//采用扩展的线程，适用:执行很多短期异步的小程序或者负载较轻的服务器

        try {
            for (int i = 0; i < 10; i++) {
                cachedThreadPool.execute(() -> {
                    System.out.println(Thread.currentThread().getName()+"\t开始执行");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            cachedThreadPool.shutdown();
        }
    }
}

观察这几个实现方法的底层源码发现，其实都是new了同一个对象即为ThreadPoolExecutor。

这里我们仔细的研究一下这个类ThreadPoolExecutor。

下面是ThreadPoolExecutor构造方法的源码

构造方法有七个参数，其中：

• corePoolSize：线程池中的常驻核心线程数，当创建线程池以后，当有任务来之后，会安排池中的请求执行请求的任务，当线程池中的线程数目达到corePoolSize后,就会把到达的任务放入到缓存队列当中。
• maximumPoolSize：线程池能够容纳同时执行的最大线程数,此值大于等于1
• keepAliveTime：多余的空闲线程存活时间，当空余时间达到keepAliveTime值时,多余的线程会被销毁直到只剩下corePoolSize个线程为止。默认情况下：只有当线程池中的线程数大于corePoolSize时keepAliveTime才会起作用,直到线程中的线程数不大于corepoolSIze。
• unit：keepAliveTime的单位
• workQueue：任务队列，被提交但是尚未执行的任务。
• threadFactory：表示生成线程池中工作线程的线程工厂,用户创建新线程,一般用默认即可。
• handler：拒绝策略，表示当线程队列满了并且工作线程大于等于线程池的最大显示 数(maxnumPoolSize)时如何来拒绝。

2.线程池的工作原理

1.当创建线程池后，等待提交过来的任务。

2.当调用execute()方法添加一个任务请求时，线程池会做出如下判断：

• 如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务。
• 如果正在运行的线程数量大于或者等于corePoolSize，那么将任务放到阻塞队列中。
• 如果队列满了而且正在运行的数量还是小于maximumPoolSize，那么还是要创建非核心线程立刻执行任务。
• 如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。

3.当线程完成任务时，他会从队列中取下一个任务执行。

4.当一个线程无事可做超过一定时间（keepAliveTime）时，线程池会判断，如果当前运行线程数大于corePoolSize，那么这个线程就是被停掉。

这里会有当等待队列中的任务已经排满了，再也塞不进新任务，同时线程池中的线程也达到了最大值的时候，无法继续为新任务服务时，就会采取拒绝策略。

JDK内置的拒绝策略有：

• AbortPolicy(默认)：直接抛出RejectedException异常阻止系统正常运行
• CallerRunPolicy："调用者运行"一种调节机制,该策略既不会抛弃任务,也不会抛出异常,而是将某些任务回退调用，从而降低任务流量。
• DiscardOldestPolicy：抛弃队列中等待最久的任务,然后把当前任务加入队列中尝试再次提交
• DiscardPolicy：直接丢弃任务,不予任何处理也不抛出异常.如果允许任务丢失,这是最好的拒绝策略

在使用线程创建的时候要注意以下的方面：

线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 说明：使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。说明：Executors返回的线程池对象的弊端如下：
1）FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
2）CachedThreadPool和ScheduledThreadPool:允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

-----参考阿里巴巴java开发手册

3.自定义线程池

public class MyThreadPoolDemo {

    public static void main(String[] args) {

        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                1,
                5,
                1L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());


        try {
            for (int i = 0; i < 10; i++) {
                poolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName()+"\t开始执行");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            poolExecutor.shutdown();
        }


    }
}

这里面会有一个问题，在创建线程池的时候，最大线程数该如何设置呢？这个还是要具体情况具体分析

当系统执行的是CPU密集型的，也就是该任务需要大量的运算，而没有阻塞，CPU一直运行。这时候尽可能少的开启线程数量。线程池中的数量最好为，CPU核数+1

当系统执行的是IO密集型，也就是任务需要大量IO，大量的阻塞。可以采用多开线程的方式为CPU核数*2.还有一种方式就是CPU核数/1-阻塞系统，通常阻塞系统在0.8到0.9之间。

尽可能少的开启线程数量。线程池中的数量最好为，CPU核数+1

当系统执行的是IO密集型，也就是任务需要大量IO，大量的阻塞。可以采用多开线程的方式为CPU核数*2.还有一种方式就是CPU核数/1-阻塞系统，通常阻塞系统在0.8到0.9之间。