线程池代码

缓存线程池

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class CachedThreadPoolExample {

　　public static void main(String[] args) {

　　ExecutorService executor = Executors.newCachedThreadPool();

　　for (int i = 0; i < 10; i++) {

　　　　Runnable task = new Task(i);

　　　　executor.execute(task);

　　}

　　executor.shutdown();

}

static class Task implements Runnable {

　　private int taskId;

　　public Task(int taskId) {

　　　　this.taskId = taskId;

　　}

　　public void run() {

　　System.out.println("Task " + taskId + " is running on thread " + Thread.currentThread().getName());

　　try {

　　　　Thread.sleep(1000);

　　} catch (InterruptedException e) {

　　　　e.printStackTrace();

}

System.out.println("Task " + taskId + " is completed");

} } }

 

配合countdownlatch使用：

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

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

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

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

构造CountDownLatch
final CountDownLatch latch = new CountDownLatch(60);//初始化，计数器容量为60
1
计数器减一
latch.countDown();//计数器容量减一
1
使调用该方法的线程处于等待状态，当倒数到0时主线程才执行。
latch.await();
1
示例：使用线程池的方式，计算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();
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
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());
}