Java线程池详解(为什么要有线程池、线程池的继承关系、线程池的底层原理、手工创建线程池、JDK内置的4大线程池)

最新推荐文章于 2024-05-08 16:47:16 发布

置顶 zhao_miao

最新推荐文章于 2024-05-08 16:47:16 发布

阅读量2.6k

点赞数 13

分类专栏： Java Java学习文章标签：为什么要有线程池？线程池的继承关系线程池的底层原理手工创建线程池 JDK内置的4大线程池

本文链接：https://blog.csdn.net/zhao_miao/article/details/88072721

版权

Java 同时被 2 个专栏收录

70 篇文章 10 订阅

订阅专栏

Java学习

53 篇文章 3 订阅

订阅专栏

1.为什么有线程池的出现？

我们之前已经了解了创建线程的三种方式：继承Thread类、实现Runnable接口，实现Callabe接口(该方法有返回值)java实现多线程的三种方式，可是既然已经有了创建线程的方式，为什么有线程池的出现呢？

假设每当一个请求到达就创建一个新的线程，为每个请求在创建和销毁线程上花费的时间和消耗的资源有可能比花在处理实际的用户需求的时间和资源还多。线程池通过重复利用已创建的线程降低线程创建和销毁带来的损耗。在请求到达时线程已经存在，任务不需要等待线程创建就可以立即执行，程序响应更快。
大多数的实际场景是处理某一次请求的时间是非常短暂的，但是请求的数量巨大，如果我们为每一个请求都单独创建一个线程，那么物理机的所有资源基本上都被操作系统创建线程、切换线程状态，销毁线程这些操作所占用。使用线程池可以统一进行线程分配、调度和监控，并且，对操作系统中最大的线程数量是有限制的，使得操作系统不会因为线程数量过多而不稳定。

综上线程池的优点有：

降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁带来的消耗。
提高响应速度：当任务到达时，任务可以不需要等待线程创建就能立即执行。
提高线程的可管理性：使用线程池可以统一进行线程分配、调度和监控。

2. 线程池的继承关系

在这里插入图片描述

3. 线程池的底层原理

当一个Callable对象或者Runnable对象到达线程池时，执行策略如下：
第一步：首先判断核心池(corePool )是否已满
如果未满，不管此时有没有空闲线程，都创建新的线程执行任务；如果已满，再次查看线程池中是否有空闲线程，若有空闲线程，则将任务交给空闲线程执行，如果没有空闲线程，执行第二步
第二步: 判断阻塞队列（BlockingQueue）是否已满
如果阻塞队列没有满，将提交的任务存储到阻塞队列中等待核心池的调度，若阻塞队列已满，进入步骤三
第三步：判断当前线程池中的线程数是否已达到最大值maxiumSize
若已经达到最大值，将任务交给饱和策略处理，否则继续创建新线程等待执行此任务。

4.线程池的创建与使用

4.1 手工创建线程池

通过创建ThreadPoolExecutor：

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

corePoolSize: 核心池的大小
当任务提交到线程池时，线程池会创建一个新的线程来执行任务，即使核心池中有其它空闲线程也会创建新线程，一直到线程数达到核心池的大小为止
调用prestartAllCoreThreads()线程池会提前创建并启动所有的核心线程。

workQueue: 阻塞队列
1.ArrayBlockingQueue: 基于数组结构的有界阻塞队列，此队列按照FIFO原则对元素进行排序
2. LinkedBlockingQueue：基于链表结构的阻塞队列，此队列按照FIFO排序元素，吞吐量高于ArrayBlockingQueue
3. SynchronousQueue：一个不存储元素的阻塞队列。无界队列。每个插入操作必须等到另一个线程的移除操作，否则插入操作将一直处于阻塞状态，吞吐量比LinkedBlockingQueue高
4. PriorityBlockingQueue:具有优先级的无界阻塞队列

maximumPoolSize: 线程池的最大线程数量
线程池允许创建的最大线程数，如果队列已满并且创建的线程数小于此参数，则线程池会再创建新的线程执行任务，否则，采用饱和策略处理。如果阻塞队列选用的是无界队列SynchronousQueue，此参数将没有意义

keepAliveTime:线程保持活动时间
线程池的工作线程空闲后，保持存活的时间。若任务很多，并且每个任务执行的时间较短，可以调大此参数来提高线程的利用率

TimeUnit（keepAliveTime的时间单位）

RejectedExecutionHandler:饱和策略
当队列和线程池都满了，说明线程池处于饱和状态，此时采用饱和策略来处理任务
默认的饱和策略是AbortPolicy JDK一共内置4个饱和策略

AbortPolicy：表示无法处理新任务抛出异常 JDK默认采用此策略
CallerRunsPolicy: 等待调用者线程空闲后执行任务。调用者线程：假设在线程A中创建线程池，线程A就是调用者线程
DiscardOldestPolicy：丢弃阻塞对列中最近的一个任务并执行当前任务
DiscardPolicy:不处理，丢弃新任务也不报错

eg:手工创建一个线程池

   /**
         * 核心线程池的大小是：3
         * 线程池的最大数量：5
         * 空闲线程的存活时间：2000
         * 空闲线程的存活时间的单位：ms
         * 工作队列：基于链表结构的阻塞队列
         * 饱和策略：没有声明默认采用AbortPolicy （无法处理新任务抛出异常）
         */
        ExecutorService executorservice =
                new ThreadPoolExecutor(3,5,
                        2000,TimeUnit.MILLISECONDS,
                        new LinkedBlockingDeque<>());

4.2 向线程池提交任务

4.2.1 execute()方法

execute()方法用于提交不需要返回值的任务，无法判断任务是否被线程池执行成功。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 10;i++){
            System.out.println(Thread.currentThread().getName()+"、"+i);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        /**
         * 核心线程池的大小是：3
         * 线程池的最大数量：5
         * 空闲线程的存活时间：2000
         * 空闲线程的存活时间的单位：ms
         * 工作队列：基于链表结构的阻塞队列
         * 饱和策略：没有声明默认采用AbortPolicy （无法处理新任务抛出异常）
         */
        ExecutorService executorservice =
                new ThreadPoolExecutor(3,5,
                        2000,TimeUnit.MILLISECONDS,
                        new LinkedBlockingDeque<>());

        for(int i = 0;i < 5;i++){
            //用于向线程池提交任务
            //execute()方法用于提交不需要返回值的任务
            executorservice.execute(thread);
        }
        //关闭线程池
        executorservice.shutdown();
    }
}

4.2.2 submit()方法

submit()方法用于提交需要返回值的任务。线程池会返回一个Future类型的对象，通过这个Future对象可以判断任务是否执行成功，并且可以通过Future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回。

import java.util.concurrent.*;
class MyThread implements Callable<String> {
    @Override
    public String call() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "、" + i);
        }
        return Thread.currentThread().getName() + "执行完毕";
    }
}
public class Test {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        /**
         * 核心线程池的大小是：3
         * 线程池的最大数量：5
         * 空闲线程的存活时间：2000
         * 空闲线程的存活时间的单位：ms
         * 工作队列：基于链表结构的阻塞队列
         * 饱和策略：没有声明默认采用AbortPolicy （无法处理新任务抛出异常）
         */
        ExecutorService executorservice =
                new ThreadPoolExecutor(3,5,
                        2000,TimeUnit.MILLISECONDS,
                        new LinkedBlockingDeque<>());

        for(int i = 0;i < 5;i++){
            //用于向线程池提交任务
            //submit()方法用于提交需要返回值的任务
            Future future = executorservice.submit(thread);
            try {
                //future.get()会阻塞其他线程 一直等到当前Callable线程执行完毕拿到返回值为止
                System.out.println(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        //关闭线程池
        executorservice.shutdown();
    }
}

在这里插入图片描述

5.JDK内置的4大线程池

5.1 普通调度池

5.1.1 无大小限制的线程池

Executors.newCashedThreadPool()

public static ExecutorService newCachedThreadPool() {
    //核心池的大小为0
    //线程池的大小为整形最大值
    //空闲线程的存活时间是60 单位s
    //工作队列是无界队列  
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

适用于很多短期任务的小程序，负载较轻的服务器任务一来就能处理

5.1.2 固定大小的线程池

Executors.newFixedThreadPool(int nThreads)

public static ExecutorService newFixedThreadPool(int nThreads) {
    //线程池的最大数量=核心池的大小 
    //线程池的线程空闲后存活时间为0
    //工作队列是基于链表的阻塞队列
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

适用于为了满足资源管理的需求而需要限制当前线程数量的应用场合适用于负载比较重的服务器

5.1.3 单线线程

Executors.newSingleThreadPool()

public static ExecutorService newSingleThreadExecutor() {
     //线程池的最大数量=核心池的大小 =1
    //空闲线程的存活时间是0
    //工作队列是基于链表的阻塞队列
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

使用于需要保证顺序的执行各个任务，并且在任意时间点，不会有多个线程活动的场景

5.2 定时调度池

5.2.1 Executors.newScheduledThreadPool()

import java.util.concurrent.*;

class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 10;i++){
            System.out.println(Thread.currentThread().getName()+"、"+i);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        ScheduledExecutorService scheduledExecutorService =
                Executors.newScheduledThreadPool(3);
        //延迟三秒后执行一次
        //scheduledExecutorService.schedule(thread,3,TimeUnit.SECONDS);
        // 延迟3秒每隔两秒执行一次
        scheduledExecutorService.scheduleAtFixedRate(thread,3,2,TimeUnit.SECONDS);
    }
}

zhao_miao

关注

13
点赞
踩
100

收藏

觉得还不错? 一键收藏
0
评论
Java线程池详解(为什么要有线程池、线程池的继承关系、线程池的底层原理、手工创建线程池、JDK内置的4大线程池)

文章目录1.为什么有线程池的出现？2. 线程池的继承关系3. 线程池的底层原理4.线程池的创建与使用4.1 手工创建线程池4.2 向线程池提交任务4.2.1 execute()方法4.2.2 submit()方法5.JDK内置的4大线程池5.1 普通调度池5.1.1 无大小限制的线程池5.1.2 固定大小的线程池5.1.3 单线线程5.2 定时调度池5.2.1 Executors.new...
复制链接

扫一扫