newFixedThreadPool线程池

• 前言
• newFixedThreadPool的介绍
• • 使用newFixedThreadPool的步骤
  • • 实例化一个固定线程大小线程池
    • 创建一个用于启动新线程的类
    • 使用submit提交线程
    • 最后关闭关闭线程池
  • CountDownLatch配合线程池使用
  • • 构造CountDownLatch
    • 计数器减一
    • 使调用该方法的线程处于等待状态，当倒数到0时主线程才执行。
  • 示例：使用线程池的方式，计算1000名学生的学习数据
  • • Main类，用于初始化线程池大小、线程提交任务
    • CalculationStudentsData类：用于执行线程，并执行具体的业务
    • 执行结果的部分截图
• 思考
• 如果博主的文章对您有所帮助，可以评论、点赞、收藏，支持一下博主!!!

前言

本篇博客的目的是让大家能够熟练的简单运用newFixedThreadPool线程池并且能够运用到具体的 项目开发中。
通过本篇博客你将完全掌握newFixedThreadPool线程池的基本运用，使用多线程进行开发。

newFixedThreadPool的介绍

newFixedTheadPool是六种常用线程池的其中一种，newFixedThreadPool的特点是他的核心线程数和最大线程数是一致的，并且是一个固定线程数的线程池。线程池的大小一旦达到最大值后，再有新的任务提交时则放入无界阻塞队列中，等到有线程空闲时，再从队列中取出任务继续执行。

newFixedThreadPool的特点：

1.创建的线程数量固定
2.创建的线程可以重复使用
3.提交一个任务，就创建一个线程，直到达到线程池的最大容量
4.有执行异常结束的线程，线程池会补充一个新的线程
5.使用无边界的队列来存储需要执行的任务
6.使用完成，需要手动关闭线程池
正是由于这些特性，使用newFixiedThreadPool进行多线程开发十分简单。

使用newFixedThreadPool的步骤

实例化一个固定线程大小线程池

//实例化一个固定大小为60个线程的newFixedThreadPool线程池
ExecutorService excutorService = Executors.newFixedThreadPool(60);

创建一个用于启动新线程的类

该类需要实现Runnable接口，并实现Runnable中的run方法
run方法中填写具体的需要线程执行的业务逻辑

public class PrintThread implements Runnable{
    public void run(){
            
        }
    }
}

使用submit提交线程

excutorService.submit();

最后关闭关闭线程池

excutorService.shutdown();

CountDownLatch配合线程池使用

CountDownLatch的作用就是等待其他线程都执行完任务，然后主线程才继续往下执行。

CountDownLatch适合于对任务进行拆分，使其并行执行，比如某个任务执行10s，其对数据的请求可以分为五个部分，那么就可以将这个任务拆分为5个子任务，分别交由五个线程执行，执行完成之后再由主线程进行汇总，此时，总的执行时间将决定于执行最慢的任务，平均来看，还是大大减少了总的执行时间。

CountDownLatch主要有两个方法：countDown（）和await（）。
countDown()方法用于使计数器减一，await（）方法则使调用该方法的线程处于等待状态，一般为主线程。当倒数到0时主线程才执行。

CountDownLatch使用主要步骤：在构造CountDownLatch的时候需要传入一个整数n，每一个线程执行完一个任务倒数一次。在这个整数倒数到0之前，主线程需要进行等待。倒数到0主线程才执行。

构造CountDownLatch

final CountDownLatch latch = new CountDownLatch(60);//初始化，计数器容量为60

计数器减一

latch.countDown();//计数器容量减一

使调用该方法的线程处于等待状态，当倒数到0时主线程才执行。

latch.await();

示例：使用线程池的方式，计算1000名学生的学习数据

Main类，用于初始化线程池大小、线程提交任务

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : Main
 * @description : [初始化线程池，线程提交任务]
 * @createTime : [2022/12/28 9:20]
 * @updateUser : [WangWei]
 * @updateTime : [2022/12/28 9:20]
 * @updateRemark : [描述说明本次修改内容]
 */
public class Main {
    public static void main(String[] args) {
        //实例化一个固定大小为5个线程的newFixedThreadPool线程池
        ExecutorService excutorService = Executors.newFixedThreadPool(10);
        //构造CountDownLatch传入数量为1000，初始化的计数器大小为1000,与学生数量对应。
        final CountDownLatch latch = new CountDownLatch(1000);
        //计算1000个学生的学习数据
        for (int i = 0; i <1000 ; i++) {
            //线程提交任务
            excutorService.submit(new CalaulationStudentsData(i,latch));
        }
        try{
            //使调用该方法的主线程处于等待状态，当倒数到0时主线程才执行。
            latch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException("学生学习数据普通版多线程处理异常",e);
        }
        //关闭线程池
        excutorService.shutdown();
    }
}

CalculationStudentsData类：用于执行线程，并执行具体的业务

import java.util.concurrent.CountDownLatch;

/**
 * @author : [WangWei]
 * @version : [v1.0]
 * @className : CalaulationStudentsData
 * @description : [计算学生学习数据]
 * @createTime : [2022/12/28 9:24]
 * @updateUser : [WangWei]
 * @updateTime : [2022/12/28 9:24]
 * @updateRemark : [描述说明本次修改内容]
 */
public class CalculationStudentsData implements Runnable{
    int studentNumber;
    CountDownLatch latch;

    /*
     * @version V1.0
     * Title: CalculationStudentsData
     * @author Wangwei
     * @description 构造函数中传入学生编号
     * @createTime  2022/12/28 9:29
     * @param [studentNumber]
     * @return
     */
    public CalculationStudentsData(int studentNumber, CountDownLatch latch){
        this.studentNumber=studentNumber;
        this.latch=latch;
    }
    /*
     * @version V1.0
     * Title: run
     * @author Wangwei
     * @description 执行线程
     * @createTime  2022/12/28 9:30
     * @param []
     * @return void
     */
    @Override
    public void run() {
        try {
            //计算学生学习数据的方法
            this.CalculationStudentData();
            //计数器减一
            latch.countDown();
        }catch (Exception e){
        	//计数器减一，避免死循环
            latch.countDown();
            throw new RuntimeException("学生学习数据子线程执行数据异常"+e);
        }
    }
    /*
     * @version V1.0
     * Title: CalaulationStudentData
     * @author Wangwei
     * @description 计算学生学习数据的方法
     * @createTime  2022/12/28 9:32
     * @param []
     * @return void
     */
    private void CalculationStudentData(){
    	//输出学生编号和执行该任务的线程名称
        System.out.println("完成学生"+studentNumber+"的学习成绩计算"+Thread.currentThread().getName());
    }
}

执行结果的部分截图

思考

1.除了介绍的newFixedThreadPool之外还有哪些线程池？
2.除了上面介绍的submit的提交任务的方式，还有哪些提交任务的方式？
3.线程池有哪些功能？
4.线程池或者是说多线程的应用场景？

如果博主的文章对您有所帮助，可以评论、点赞、收藏，支持一下博主!!!