当对Kafka中的数据进行解析时,由于数据量大,可以对Java开启多线程的处理,这里使用的 ThreadPoolExecutor 可以直接拿过来是使用。
目录
2、ThreadPoolExecutor执行execute()方法的示意图
前言
Java 中如何快速使用线程池来进行处理呢?直接使用第三方接口 ThreadPoolExecutor
一、线程池的作用是什么?
线程池的工作主要是控制运行的线程的数量,处理过程中将任务放入队列,然后在线程创建后启动这些任务,如果线程数量超过了最大数量,那么超出数量的线程排队等候,等其他线程执行完毕再从队列中取出任务来执行。
二、使用线程池的好处
- 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗;
- 提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行;
- 提高线程的可管理性。线程是稀缺资源,如果无限制地创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一分配、调优和监控。
三、线程池实现原理
1、线程池处理流程
2、ThreadPoolExecutor执行execute()方法的示意图
二、使用步骤
1.引入库
代码如下:
import java.util.concurrent.ThreadPoolExecutor
2.创建线程池
代码如下:通过ThreadPoolExecutor创建
// 定义线程池
private static final ThreadPoolExecutor EXECUTOR1 = new ThreadPoolExecutor(2500,
4500,
100L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(7000),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
// 引用线程池
for (ConsumerRecord<String, String> record : records) {
EXECUTOR.execute(new Runnable() {
@Override
public void run() {
//程序的具体执行逻辑
}
});
}
3.ThreadPoolExecutor函数介绍
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
- corePoolSize:线程池的核心线程数,定义了最小可以同时运行的线程数量。
- maximumPoolSize:线程池的最大线程数。方队列中存放的任务达到队列容量时,房前可以同时运行的线程数量变为最大线程数。
- keepAliveTime:当线程池中的线程数量大于corePoolSize时,如果没有新任务提交,核心线程外的线程不会立即销毁,而是会等待,直到等待的时间超过了KeepAliveTime才会被回收销毁。
- unit:keepAliveTime参数的时间单位,包括DAYS、HOURS、MINUTES、MILLISECONDS等。
- workQueue:用于保存等待执行任务的阻塞队列。可以选择以下集个阻塞队列:
ArrayBlockingQueue数组BlockingQueue:是一个基于数组结构的阻塞队列,此队列按FIFO原则对元素进行排序;LinkedBlockingQueue:是一个基于链表结构的阻塞队列,此队列按FIFO排序元素,吞吐量通常高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。SynchronousQueue同步队列:一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作,否则插入操作一直处于阻塞状态,吞吐量常高于 LinkedBlockingQueue,静态工厂方法Executors.newCachedThreadPool() 使用了这个队列。PriorityBlockingQueue:一个具有优先级的无限阻塞队列。
- threadFactory:用于设置创建线程的工厂,可以通过工厂给每个创造出来的线程设置更有意义的名字。使用开源框架guava提供的ThreadFactoryBuilder可以快速给线程池里的线程设置有意义的名字:
- new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build();
- new ThreadFactoryBuilder().setNameFormat(“XX-task-%d”).build();
- handler:饱和策略。若当前同时运行的线程数量达到最大线程数量并且队列已经被放满,ThreadPoolExecutor定义了一些饱和策略:
ThreadPoolExecutor.AbortPolicy:直接抛出RejectedExecutionException异常来拒绝处理新任务;
ThreadPoolExecutor.CallerRunsPolicy:只用调用者所在的线程来运行任务,会降低新任务的提交速度,影响程序的整体性能。
ThreadPoolExecutor.DiscardPolicy:不处理新任务,直接丢弃掉。 ThreadPoolExecutor.DiscardOldestPolicy:丢弃队列中最近的一个任务,执行当前任务。
4. 向线程池提交任务
- execute()方法用于像线程池提交不需要返回值的任务,所以无法判断任务是否被线程池执行成功。
executor.execute(new Runnable() {
@Override
public void run() {
// TODO
}
});
- submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象,通过这个future对象可以判断任务是否执行成功,并且可以通过future的get()方法获取返回值,get()方法会阻塞当前线程直到任务完成,而使用get(long timeout, TimeUnit unit)方法则会阻塞当前线程一段时间后立即返回,这时有可能任务还没有执行完。
Future<T> future = EXECUTOR.submit(hasReturnValueTask);
try {
T s = future.get();
} catch (Excception e) {
// 处理异常 e.printStackTrace();
} finally {
// 关闭线程池 executor.shutdown();
}
5.关闭线程池
使用线程池的shutdown或shutdownNow方法来关闭线程池。其原理在于遍历线程池中的工作线程,然后逐个调用线程的interrupt方法来中断线程,所以无法响应中断的任务可能无法终止。
二者区别在于:shutdownNow方法首先将线程池状态设置为STOP,然后尝试停止所有正在执行或暂停任务的线程,并返回等到执行任务的列表,而shutdown只是将线程池的状态设置为SHUTDOWN状态,然后中断所有没有整在执行任务的线程。
6. 合理配置线程池
查看当前设备的CPU核数:
Runtime.getRuntime().availableProcessors();
- CPU密集型任务:任务需要大量的运算,而没有阻塞,CPU一直全速运行。CPU密集型任务配置尽可能的少的线程数量。公式:CPU核数 + 1个线程的线程池。
- IO密集型任务:任务需要大量的IO,即大量的阻塞。由于IO密集型任务线程并不是一直在执行任务,可以多分配一点线程数,如CPU核数*2。公式:CPU核数/(1-阻塞系数),其中阻塞系数在0.8-0.9之间。
总结
在实际应用中,比如我是处理各种各样的数据的,由于每一类数据的复杂程度不一样,有时会造成资源等待的问题,但是如果是处理的数据难易程度差不多时,效果还是很显著的。
代码
package cn.ac.ii;
import cn.ac.ii.kafka.Kafka;
import cn.ac.ii.tool.ConstUtil;
import cn.ac.ii.tool.MyTools;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Arrays;
import java.util.Map;
import java.util.concurrent.*;
/**
* @author 一夜飘零
* @create 2022-05-26 10:07
*/
@Slf4j
public class Metrics_App {
private static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(2500, 4500, 100L, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(7000), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
public void running() {
// 1、连接到kafka
KafkaConsumer<String, String> kafkaConsumer =
Kafka.getKafkaConsumer(ConstUtil.KAFKA_QUORUM, "group10",true);
// true是latest
kafkaConsumer.subscribe(Arrays.asList(ConstUtil.METRICS_TOPIC_NAME));
Map<String, JSONObject> extracted = null;
while (true) {
ConsumerRecords<String, String> records = kafkaConsumer.poll(10);
if (!records.isEmpty()) {
// 2、 将plugins_plugin中data不为空的过滤出来
for (ConsumerRecord<String, String> record : records) {
EXECUTOR.execute(new Runnable() {
@Override
public void run() {
//实际要的处理逻辑部分
}
});
}
}
}
}
public static void main(String[] args) {
Metrics_App rk = new Metrics_App();
rk.running(); // 正常业务的
}
}