线程池的使用

素颜马尾好姑娘i 2023-10-08 17:44 68阅读 0赞

1.  为什么要使用线程池  
    复习一下创建线程的几种方式：

> 继承Thread  
> 实现Runnable  
> 实现Callable

但是如果频繁的创建/销毁线程，就会造成资源浪费。这时候就需要将线程创建好之后存起来，以后要用取出来，用完后再放回去。

注意 ：线程池并不是一种新的线程创建方法，它也是靠上面的方式创建线程的，只不过它能保存线程，实现线程资源的重复利用。

为什么要学线程池？效率高？牛逼？错，面试喜欢问。。。

1.  Executor  
    创建之前首先要来认识一下它 ：Executor。

Executor是线程池的根接口

![在这里插入图片描述][df756258dece4220bb6d920e36398c0b.png_pic_center]  
3. ThreadPoolExecutor  
3.1 七个参数  
在创建线程池之前先来看看它的7个参数：

new ThreadPoolExecutor(int corePoolSize, 
                           int maximumPoolSize,
                           long keepAliveTime,
                           TimeUnit unit,
                           BlockingQueue<Runnable> workQueue,
                           ThreadFactory threadFactory,
                           RejectedExecutionHandler handler)

![在这里插入图片描述][0893e60981a745a0a50dfcc61039ac0c.png_pic_center]

corePoolSize

线程池核心线程数。

默认情况下核心线程会一直存活，即使处于闲置状态也不会受存keepAliveTime限制，除非将allowCoreThreadTimeOut设置为true。

maximumPoolSize

线程池所能容纳的最大线程数。超过maximumPoolSize的线程将被阻塞。

最大线程数maximumPoolSize不能小于corePoolSize

keepAliveTime

临时线程的闲置超时时间。超过这个时间临时线程就会被回收。

即 ：核心线程被创建后一直存活，临时线程如果在闲置时间(keepAliveTime)内没有接到新任务会被销毁。

TimeUnit

keepAliveTime的时间单位，如TimeUnit.SECONDS。表示：keepAliveTime的单位是秒

workQueue

线程池中的任务队列。

没有获得线程资源的任务将会被放入workQueue，等待线程资源被释放。

如果核心线程数满了，新来的任务会首先放入任务队列

如果任务队列满了，会额外创建临时线程完成任务

如果线程数到达最大线程数时任务队列还是满的，多余的任务将由RejectedExecutionHandler的拒绝策略进行处理。

常用的有三种队列： SynchronousQueue,LinkedBlockingDeque,ArrayBlockingQueue。

threadFactory

提供创建新线程功能的线程工厂。通过threadFactory程序员可以自定义线程池中线程的创建方法。

ThreadFactory是一个接口，只有一个newThread方法：

Thread newThread(Runnable r);

rejectedExecutionHandler

拒绝策略，无法被线程池处理的任务的处理器。

一般是因为任务数超出了workQueue的容量。  
3.2 任务队列  
常用的三个队列 ：

> SynchronousQueue ：无界缓冲等待队列。没有容量，是不储存元素的阻塞队列，会直接将任务交给线程，必须等队列中的添加元素表内消费后才能继续添加新的元素。即每次只能装一个任务，被线程拿走后才能继续接收任务。  
> 使用SynchronousQueue阻塞队列一般要求最大线程数为无界，避免线程拒绝执行操作。
> 
> LinkedBlockingDeque：无界缓冲等待队列。当前执行的线程数量达到核心线程数时，剩余的元素会在阻塞队列里等待，即一次性拿走所有任务，有多少新来的也能装入，等待线程一个一个执行。（该队列默认大小为Integer.MAX\_VALUE）
> 
> ArrayBlockingQueue ：有界缓存等待队列。有容量，可以指定缓存队列的大小。只能装指定容量的任务，被线程拿走后才能继续装。

3.3 拒绝策略  
常用的四个拒绝策略 ：（它们都是ThreadPoolExecutor的内部类）

> AbortPolicy ：丢弃多余任务，抛出异常。默认策略。
> 
> DiscardPolicy ：丢弃新任务，不抛出异常。假如新来5个任务想进入队列，丢弃他们。
> 
> DiscardOldestPolicy ：丢弃旧任务，不抛出异常。假如新来5个任务想进入队列，将任务队列中的前五个丢弃，新来的进入队列。  
> CallerRunsPolicy ：不抛弃任务，创建线程池的线程帮忙执行任务（例如main）。

1.  创建线程池  
    现在就用刚才所学的知识创建一个线程池并让它执行一些任务。

首先创建一个任务类，处理响应任务

public class Task implements Runnable{
        
        public String name;
    
        public Task(String name) {
        
            this.name = name;
        }
        @Override
        public void run() {
        
            System.out.println("线程: " + name + " 执行任务");
        }
    }

紧接着就可以创建线程池，这里我们创建一个 ：

核心线程数为2，最大线程数为5，存活时间为10s，队列使用ArrayBlockingQueue，拒绝策略使用CallerRunsPolicy（创建线程池的线程帮忙执行多余任务）

让它处理20个任务 ：

public class Main {
        
        public static void main(String[] args) {
        
            ThreadPoolExecutor executor = new ThreadPoolExecutor(
                    2,
                    5,
                    10,
                    TimeUnit.SECONDS, 
                    new ArrayBlockingQueue<Runnable>(5),
                    new ThreadPoolExecutor.CallerRunsPolicy()
            );
            for (int i = 0; i < 20; i++) {
        
                try {
        
                    executor.execute(new Task(i + ""));
                } catch (Throwable e) {
        
                    System.out.println("丢弃任务: " + (i));
                }
            }
        }
    }

![在这里插入图片描述][baa7e30b52b4440dbe1b6923999ec762.png_pic_center]

但是也可以注意到，任务已经执行结束，但是程序还未关闭，这就证明线程池并不会主动关闭，需要我们调用executor.shutdown()关闭并回收线程池。

1.  Executors  
    Java提供了Executors工具类来创建线程池，注意它只是一个工具类，就像Strings是String的工具类、Objects是Object的工具类一样。Executors创建的线程池都是ExecutorService的实现类。

但是Executors这种方式创建的线程池是JDK提供的，有很多细节无法把控，所以阿里规范禁止使用Executors来创建线程池。  
【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。  
说明：  
Executors返回的线程池对象的弊端如下：

1）FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
    2）CachedThreadPool和ScheduledThreadPool:允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

但是这里依旧要说一下这几种线程池，毕竟是官方封装的。而且后面自己写demo也可以直接用。

这几种线程池也是通过new ThreadPoolExecutor() 创建的，只不过其中的参数不同，所实现的功能也不同。

5.1 CachedThreadPool  
Executors.newCachedThreadPool()

可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

public static ExecutorService newCachedThreadPool() {
        
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

核心线程数为0，任务队列只能装一个任务。也就是 只要来一个任务就创建一个线程处理它，来多少任务就创建多少线程。这些线程有60s的存活时间，如果接不到新任务就会被回收。

比起手动new线程，这个线程池可以实现线程复用、线程超时回收。但是可能创建太多线程造成资源浪费。

5.2 FixedThreadPool  
Executors.newFixedThreadPool(int nThread)

定长线程池，可控制最大并发线程数量，超出的线程会在队列中等待。

public static ExecutorService newFixedThreadPool(int nThreads) {
        
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

核心线程数 = 最大线程数，核心线程数满了之后任务在队列中等待，队列满了之后直接执行拒绝策略，而不是创建临时线程，因为没有线程。

5.3 SingleThreadExecutor  
Executors.newSingleThreadExecutor()

单例线程池 ：只会用唯一的线程工作，保证所有任务按照FIFL、LIFO优先级执行。

public static ExecutorService newSingleThreadExecutor() {
        
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

核心线程数 = 最大线程数 = 1，只有一个线程，所有任务都由它处理，任务队列LinkedBlockingQueue可以一次性装很多任务，这些任务排着队等待唯一的线程执行。

5.4 ScheduledThreadPoolExecutor  
调度线程池，定长，支持定时及周期性任务执行，延迟任务执行。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    ------
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

可以指定核心线程数，最大线程数是Integer.MAX\_VALUE，可以实现延时执行、周期执行。

延时执行 ：

delay 延时时间。

// 参数 : 任务 + 时间 + 时间单位
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);

周期执行 ：

initialDelay 第一次执行的延时时间  
period 每一次执行的间隔时间。

// 参数 : 任务 + 时间 + 时间单位
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);

1.  ExecutorService  
    刚刚说了，Executors创建的都是ExecutorService的子类，那么现在来使用一下ExecutorService完成任务。

先来看看它拥有的方法：

![在这里插入图片描述][effe9c3cb1f14fafaba32c595d1217f4.png_pic_center]  
shutdown ：任务执行完毕后销毁线程池。  
shutdownNow ：立即销毁线程池。  
invokeAll ：执行所有任务。  
submit ：提交并执行任务。

public class TestExecutorService {
        
        public static void main(String[] args) {
        
            ExecutorService executorService = Executors.newCachedThreadPool();
            for (int i = 0; i < 10; i++) {
        
                executorService.submit(() -> {
        
                    System.out.println(Thread.currentThread().getName() + " 执行");
                });
            }
            
            System.out.println(executorService.isShutdown());
            executorService.shutdown();
            System.out.println(executorService.isShutdown());
        }
    }

结果：

pool-1-thread-2 执行
    pool-1-thread-5 执行
    pool-1-thread-6 执行
    pool-1-thread-4 执行
    pool-1-thread-1 执行
    pool-1-thread-3 执行
    false
    pool-1-thread-8 执行
    pool-1-thread-7 执行
    pool-1-thread-9 执行
    pool-1-thread-4 执行
    true
    ——————

[df756258dece4220bb6d920e36398c0b.png_pic_center]: https://img-blog.csdnimg.cn/df756258dece4220bb6d920e36398c0b.png#pic_center
[0893e60981a745a0a50dfcc61039ac0c.png_pic_center]: https://img-blog.csdnimg.cn/0893e60981a745a0a50dfcc61039ac0c.png#pic_center
[baa7e30b52b4440dbe1b6923999ec762.png_pic_center]: https://img-blog.csdnimg.cn/baa7e30b52b4440dbe1b6923999ec762.png#pic_center
[effe9c3cb1f14fafaba32c595d1217f4.png_pic_center]: https://img-blog.csdnimg.cn/effe9c3cb1f14fafaba32c595d1217f4.png#pic_center