java线程池ExecutorService批量导入数据概要类设计使用

最新推荐文章于 2024-06-12 17:08:22 发布
最新推荐文章于 2024-06-12 17:08:22 发布
阅读量298 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaogg3678/article/details/109499108
版权 
java线程池批量导入数据
@Component
public class WifiAndImsiImportTask {
	private final int INSERNUM = 50000;//每次添加的条数
	private  final String FILE_SEPARATOR = System.getProperty("file.separator");
	private Logger logger = LoggerFactory.getLogger(getClass());
	private String policeStationid;
	private String policeAreaid;
	private String policeProvinceid;
	ExecutorService threadPool = null;//线程池
	Map<String, Object> mapImsiLocation=null;
	@Resource
	WifiAndImsiImportService wifiAndImsiImportService;

	@Scheduled(cron = "0 0/5 * * * ?")
	public synchronized void runTask() {
		if (threadPool == null) {//初始化线程池
			threadPool = Executors.newFixedThreadPool(10);
		}
		policeStationid = SysDictUtils.getDictByCode("policeStationid", "policeStationid");
		policeAreaid = SysDictUtils.getDictByCode("policeAreaid", "policeAreaid");
		policeProvinceid = SysDictUtils.getDictByCode("provinceid", "provinceid");
		
		logger.info("============================================数据导入开始===================================================");
		importData();
		logger.info("============================================数据导入结束====================================================");
	}
	public void importData() {
		List<WifiImportEntity> wifiList = new ArrayList<WifiImportEntity>();//存放wifi数据
		List<IMSIImportEntity> imsiList = new ArrayList<IMSIImportEntity>();//存放IMSI数据
		StringBuffer wifiIds = new StringBuffer();
		StringBuffer imsiIds = new StringBuffer();
		
		List<Map<String,Object>> dataList = wifiAndImsiImportService.getWaitImportData();//待导入数据
		for (Map<String,Object> map : dataList) {
			String ID = "";
			try {
				ID = map.get("id").toString();
				String fileName = map.get("filename").toString();
				String filePath = map.get("filepath").toString();
				List<String> fileList = FileUtils.readLines(new File(filePath+FILE_SEPARATOR+fileName), "UTF-8");
				wifiAndImsiImportService.updateStatus(ID, "1");
				if (map.get("filetype")!= null && "1".equals(map.get("filetype"))) {
					wifiIds.append(ID).append(",");
					wifiImportData(wifiList, fileList, fileName,wifiIds);		
				} else {
					if(mapImsiLocation == null && "3".equals(map.get("filetype"))){
						logger.info("==================开始获取归属地============================");
						long starttime = System.currentTimeMillis();
						mapImsiLocation= wifiAndImsiImportService.getImsiLocation();
						logger.info("===耗时："+(System.currentTimeMillis()-starttime)+"毫秒====");
					}
					imsiIds.append(ID).append(",");
					iMSIImportData(imsiList, fileList, fileName,imsiIds,map.get("filetype").toString());
				}
			} catch(Exception e) {
				logger.error("数据导入》》》"+e.toString());
				wifiAndImsiImportService.updateStatus(ID, "-1");
			}
		}
		insertSurplusData(wifiList, imsiList, wifiIds, imsiIds);//处理数量不满足的数据
	}
	/**
	 * 入库剩余文件
	 * */
	public void insertSurplusData(List<WifiImportEntity> wifiList,List<IMSIImportEntity> imsiList,StringBuffer wifiIds,StringBuffer imsiIds) {
		if (wifiList != null && wifiList.size()>0) {
			try{
				logger.info("============================================WIFI入库开始===================================================");
				Future<Boolean> hotWifi = threadPool.submit(new HotWifiImport(wifiList,wifiAndImsiImportService));
				Future<Boolean> hotWifihis = threadPool.submit(new HotWifiHisImport(wifiList,wifiAndImsiImportService));
				boolean b = hotWifi.get();
				boolean b1 = hotWifihis.get();
				wifiList.clear();
				wifiAndImsiImportService.updateStatus(wifiIds.toString(), "2");
				wifiIds.setLength(0);//清空Stringbuffer
				logger.info("============================================WIFI入库结束=================================");
			} catch(Exception e) {
				wifiList.clear();
				wifiAndImsiImportService.updateStatus(wifiIds.toString(), "-1");
				wifiIds.setLength(0);//清空Stringbuffer
				logger.error(e.toString());
			}
		}
		if (imsiList != null && imsiList.size()>0) {
			try{
				logger.info("============================================IMSI入库开始===================================================");
				Future<Boolean> imsiWifi = threadPool.submit(new HotImsiImport(imsiList, wifiAndImsiImportService));
				Future<Boolean> imsiWifihis = threadPool.submit(new HotImsiHisImport(imsiList, wifiAndImsiImportService));
				boolean b = imsiWifi.get();
				boolean b1 = imsiWifihis.get();
				imsiList.clear();
				wifiAndImsiImportService.updateStatus(imsiIds.toString(), "2");
				imsiIds.setLength(0);//清空Stringbuffer
				logger.info("============================================IMSI入库结束条数据=================================");
			} catch(Exception e) {
				imsiList.clear();
				wifiAndImsiImportService.updateStatus(imsiIds.toString(), "-1");
				imsiIds.setLength(0);//清空Stringbuffer
				logger.error(e.toString());
			}
		}
	}
}


//IMSI完整数据入库
class HotImsiHisImport implements Callable<Boolean>{
	List<IMSIImportEntity> list = null;
	WifiAndImsiImportService wifiAndImsiImportService;
	
	public HotImsiHisImport(List<IMSIImportEntity> list,WifiAndImsiImportService wifiAndImsiImportService) {
		this.list = list;
		this.wifiAndImsiImportService = wifiAndImsiImportService;
	}
	@Override
	public Boolean call() {
		try {
			int insertNum = wifiAndImsiImportService.insertIMSIData(list,"social_hot_imeilog_his");
			if (insertNum < 0) {
				return false;
			}
		}catch(Exception e) {
			return false;
		}
		return true;
	}
}

//IMSI数据入库
class HotImsiImport implements Callable<Boolean>{
	private Logger logger = LoggerFactory.getLogger(getClass());
	List<IMSIImportEntity> list = null;
	WifiAndImsiImportService wifiAndImsiImportService;
	private String hotArea;
	public HotImsiImport(List<IMSIImportEntity> list,WifiAndImsiImportService wifiAndImsiImportService) {
		this.list = list;
		this.wifiAndImsiImportService = wifiAndImsiImportService;
		hotArea = SysDictUtils.getDictByCode("hot", "hotaera");//热点区域
	}
	@Override
	public Boolean call() {
		try {
			List<IMSIImportEntity> anasisList = new ArrayList<IMSIImportEntity>();
			List<String> imsiRedList = HotRedListTask.getImsiRedList();
			for (IMSIImportEntity importEntity : list) {
				if (!(imsiRedList.contains(importEntity.getImsi()))) {
					String starttime = importEntity.getStarttime();
					starttime = starttime.replace("\"", "");
					String[] starttimes = starttime.split("\\s+");
					String time = starttimes[0];
					String hour = starttimes[1].split(":")[0];
					String location = importEntity.getLocation();
					if (location == null || "".equals(location)) {
						location = "其他";
					}
					importEntity.setGroupBySiteStatic(importEntity.getWsiteid()+"|"+importEntity.getWagentid()+"|"+time);
					importEntity.setGroupBySiteTime(importEntity.getWsiteid()+"|"+time+"|"+hour);
					importEntity.setGroupBySiteLocation(importEntity.getWsiteid()+"|"+importEntity.getWagentid()+"|"+time+"|"+location);
					importEntity.setGroupBySiteTimeIMSI(importEntity.getImsi()+"|"+importEntity.getWsiteid()+"|"+time);
					anasisList.add(importEntity);
				}
			}
			anasisData(anasisList);//数据分析
			warmResult(anasisList);//预警结果分析
			int insertNum  = wifiAndImsiImportService.insertIMSIData(anasisList,"social_hot_imeilog");//数据入库
			if (insertNum < 0) {
				return false;
			}
		}catch(Exception e) {
			return false;
		}
		return true;
	}
	//统计IMEI个数
	public int getIMEITotal(List<IMSIImportEntity> list) {
		int count = 0;
		for(IMSIImportEntity iMSIImportEntity:list) {
			try {
				if (iMSIImportEntity.getImei() != null && !"".equals(iMSIImportEntity.getImei()) && !"000000000000000".equals(iMSIImportEntity.getImei())) {
					count++;
				}
			} catch(Exception e) {
				
			}
		}
		return count;
	}
	/**
	 * 数据分析
	 * */
	 public boolean anasisData(List<IMSIImportEntity> anasisList) {
		 try{
				String policeAreaid = SysDictUtils.getDictByCode("policeAreaid", "policeAreaid");
				String policeProvinceid = SysDictUtils.getDictByCode("provinceid", "provinceid");
				
				List<Map<String,Object>> updateHotSiteStaticList = new ArrayList<>();//站点时间数量统计-修改
				List<Map<String,Object>> updateHotSiteTimeList = new ArrayList<>();//站点时间小时数量统计-修改
				List<Map<String,Object>> updateHotSiteLocationList = new ArrayList<>();//站点时间归属地数量统计-修改
				List<Map<String,Object>> updateHotSiteIMSITimeList = new ArrayList<>();//IMSI站点时间-修改
				
				List<Map<String,Object>> insertHotSiteStaticList = new ArrayList<>();//站点时间数量统计-添加
				List<Map<String,Object>> insertHotSiteTimeList = new ArrayList<>();//站点时间小时数量统计-添加
				List<Map<String,Object>> insertHotSiteLocationList = new ArrayList<>();//站点时间归属地数量统计-添加
				List<Map<String,Object>> insertHotSiteIMSITimeList = new ArrayList<>();//IMSI站点时间-添加
				
				List<Map<String,Object>> hotSiteStaticList = wifiAndImsiImportService.getSiteStatic();//已存在站点时间
				List<Map<String,Object>> hotSiteTimeList = wifiAndImsiImportService.getSiteStaticTime();//已存在站点时间小时
				List<Map<String,Object>> hotSiteLocationList = wifiAndImsiImportService.getSiteStaticLocation();//已存在站点时间归属地
				List<Map<String,Object>> hotSiteIMSITimeList = wifiAndImsiImportService.getIMSISite();//已存在IMSI站点时间
				
				Map<String, List<IMSIImportEntity>> hotSiteStaticMap = anasisList.stream().collect(Collectors.groupingBy(IMSIImportEntity::getGroupBySiteStatic));
				Map<String, List<IMSIImportEntity>> hotSiteTimeMap = anasisList.stream().collect(Collectors.groupingBy(IMSIImportEntity::getGroupBySiteTime));
				Map<String, List<IMSIImportEntity>> hotSiteLocationMap = anasisList.stream().collect(Collectors.groupingBy(IMSIImportEntity::getGroupBySiteLocation));
				Map<String, List<IMSIImportEntity>> hotSiteIMSITimeMap = anasisList.stream().collect(Collectors.groupingBy(IMSIImportEntity::getGroupBySiteTimeIMSI));
				for (String key : hotSiteStaticMap.keySet()) {
					try {
						  Map<String, Object> resultMap = new HashMap<String, Object>();
						  String[] keys = key.split("\\|");
						  resultMap.put("SITEID", keys[0]);
						  resultMap.put("AGENTID", keys[1]);
						  resultMap.put("STATICTIME", keys[2]);
						  resultMap.put("PROVINCEID", policeProvinceid);
						  resultMap.put("AREAID", policeAreaid);
						  resultMap.put("TYPE", "3");//类型：1：热点wifi,2:嗅探wifi,3:imsi
						  if (hotSiteStaticList.contains(resultMap)) {//表示数据已存在则修改总数
							  resultMap.put("TOTAL", hotSiteStaticMap.get(key).size());//不能放在if外边否则会影响判断
							  updateHotSiteStaticList.add(resultMap);
						  } else {
							  resultMap.put("TOTAL", hotSiteStaticMap.get(key).size());
							  insertHotSiteStaticList.add(resultMap);
						  }
						  
						  Map<String, Object> resultIMEIMap = new HashMap<String, Object>();
						  resultIMEIMap.put("SITEID", keys[0]);
						  resultIMEIMap.put("AGENTID", keys[1]);
						  resultIMEIMap.put("STATICTIME", keys[2]);
						  resultIMEIMap.put("PROVINCEID", policeProvinceid);
						  resultIMEIMap.put("AREAID", policeAreaid);
						  resultIMEIMap.put("TYPE", "4");//类型：1：热点wifi,2:嗅探wifi,3:imsi
						  if (hotSiteStaticList.contains(resultIMEIMap)) {//表示数据已存在则修改总数
							  resultIMEIMap.put("TOTAL", getIMEITotal(hotSiteStaticMap.get(key)));//不能放在if外边否则会影响判断
							  updateHotSiteStaticList.add(resultIMEIMap);
						  } else {
							  resultIMEIMap.put("TOTAL", getIMEITotal(hotSiteStaticMap.get(key)));
							  insertHotSiteStaticList.add(resultIMEIMap);
						  }
					} catch(Exception e) {
						e.printStackTrace();
					}
				}
				for (String key : hotSiteTimeMap.keySet()) {
					try {
						  Map<String, Object> resulTimetMap = new HashMap<String, Object>();
						  String[] keys = key.split("\\|");
						  resulTimetMap.put("SITEID", keys[0]);
						  resulTimetMap.put("STATICTIME", keys[1]);
						  resulTimetMap.put("STATICHOUR", keys[2]);
						  resulTimetMap.put("PROVINCEID", policeProvinceid);
						  resulTimetMap.put("AREAID", policeAreaid);
						  resulTimetMap.put("TYPE", "3");//类型：1：热点wifi,2:嗅探wifi,3:imsi
						  if (hotSiteTimeList.contains(resulTimetMap)) {//表示数据已存在则修改总数
							  resulTimetMap.put("TOTAL", hotSiteTimeMap.get(key).size());//不能放在if外边否则会影响判断
							  updateHotSiteTimeList.add(resulTimetMap);
						  }else {
							  resulTimetMap.put("TOTAL", hotSiteTimeMap.get(key).size());//不能放在if外边否则会影响判断
							  insertHotSiteTimeList.add(resulTimetMap);
						  }
					} catch(Exception e) {
						e.printStackTrace();
					}
				}
				//importEntity.setGroupBySiteLocation(importEntity.getWsiteid()+"|"+importEntity.getWagentid()+"|"+time+"|"+location);
				for (String key : hotSiteLocationMap.keySet()) {
					try {
						Map<String,Object> resultLocationMap = new HashMap<String,Object>();
						String[] keys = key.split("\\|");
						resultLocationMap.put("SITEID",keys[0]);
						resultLocationMap.put("AGENTID",keys[1]);
						resultLocationMap.put("STATICTIME",keys[2]);
						String location = keys[3];
						String[] locations = locationPattren(location);
						resultLocationMap.put("LOCATIONPROVINCENAME", locations[0]);
						resultLocationMap.put("LOCATIONAREANAME", locations[1]);
						//resultLocationMap.put("TOTAL", hotSiteLocationMap.get(key).size());
						resultLocationMap.put("PROVINCEID", policeProvinceid);
						resultLocationMap.put("AREAID", policeAreaid);
						  if (hotSiteLocationList.contains(resultLocationMap)) {//表示数据已存在则修改总数
							  resultLocationMap.put("TOTAL", hotSiteLocationMap.get(key).size());//不能放在if外边否则会影响判断
							  updateHotSiteLocationList.add(resultLocationMap);
						  }else {
							  resultLocationMap.put("TOTAL", hotSiteLocationMap.get(key).size());//不能放在if外边否则会影响判断
							  insertHotSiteLocationList.add(resultLocationMap);
						  }
					} catch(Exception e) {
						e.printStackTrace();
					}
				}
				if (hotArea.equals("1")) {
					logger.info("============================开始遍历IMSI异常站点数据=======================================================================");
					long starttime = System.currentTimeMillis();
					insertHotSiteIMSITimeList = compareForIMSISite(hotSiteIMSITimeList,hotSiteIMSITimeMap);
					logger.info("============================耗时："+(System.currentTimeMillis()-starttime)+"毫秒==========================================");
				}
				wifiAndImsiImportService.updateSiteStatic(updateHotSiteStaticList);
				wifiAndImsiImportService.updateSiteStaticTime(updateHotSiteTimeList);
				wifiAndImsiImportService.updateSiteStaticLocation(updateHotSiteLocationList);
				wifiAndImsiImportService.updateIMSISite(updateHotSiteIMSITimeList);

				wifiAndImsiImportService.insertSiteStatic(insertHotSiteStaticList);
				wifiAndImsiImportService.insertSiteStaticTime(insertHotSiteTimeList);
				wifiAndImsiImportService.insertSiteStaticLocation(insertHotSiteLocationList);
				wifiAndImsiImportService.insertIMSISite(insertHotSiteIMSITimeList);
		 } catch(Exception e) {
			 e.printStackTrace();
			 return false;
		 }
		 return true;
	 }
	 /**
	  * 轨迹分析入库比较方法
	  * */
	 public List<Map<String,Object>> compareForIMSISite(List<Map<String,Object>> sourceList,Map<String, List<IMSIImportEntity>> hotSiteIMSITimeMap) {
		 Set<String> dataByFileSet = new HashSet<String>();//文件中获取的数据
		 Set<String> dataByDataSet = new HashSet<String>();//数据库中获取的数据
		 Set<String> tempSet = new HashSet<String>();//临时集合
		 for (String key : hotSiteIMSITimeMap.keySet()) {//Map数据转为set集合
				try {
					  String[] keys = key.split("\\|");
					  String IMSI = keys[0];
					  String SITEID = keys[1];
					  String STATICDAY = keys[2];
					  String compareValue = IMSI+"|"+SITEID+"|"+STATICDAY;
					  dataByFileSet.add(compareValue);
				} catch(Exception e) {
					logger.error(e.toString());
				}
			}
		 for (Map<String,Object> map : sourceList) {
			 String compareValue = map.get("COMPAREVALUE").toString();
			 dataByDataSet.add(compareValue);
		 }
		 tempSet.addAll(dataByFileSet);
		 tempSet.removeAll(dataByDataSet);
		 List<Map<String,Object>> list = new ArrayList<>();//IMSI站点时间-修改
		 for (String s : tempSet) {//转为list集合
			 try{
				 String[] ss = s.split("\\|");
				 Map<String,Object> params = new HashMap<String,Object>();
				 params.put("IMSI", ss[0]);
				 params.put("SITEID", ss[1]);
				 params.put("STATICDAY", ss[2]);
				 list.add(params);
			 }catch(Exception e) {
				 logger.error(e.toString());
			 }
		 }
		 return list;
	 }
	 public String[] locationPattren(String location) {
		 String[] result = new String[2];
		 if (location == null || "".equals(location)) {
			 result[0] = "其他";
			 result[1] = "其他";
		 } else if(Pattern.matches(".*-.*", location)){
			 result[0] = location.split("-")[0];
			 result[1] = location.split("-")[1];
		 } else if(Pattern.matches(".*省.*市", location)){
			 result[0] = location.split("省")[0];
			 String s = location.split("省")[1];
			 result[1] = s.substring(0, s.length()-1);
		 } else if(Pattern.matches(".*省.*", location)){
			 result[0] = location.split("省")[0];
			 result[1] = location.split("省")[1];
		 } else if(Pattern.matches(".*市.*", location)){
			 if (location.split("市").length > 1) {
				 result[0] = location.split("市")[0];
				 result[1] = location.split("市")[1]; 
			 } else {
				 result[0] = location.split("市")[0];
				 result[1] = "其他";
			 }
		 } else {
			 List<String> plist = new ArrayList<String>();
			 plist.add("内蒙古");
			 plist.add("广西");
			 plist.add("西藏");
			 plist.add("宁夏");
			 plist.add("新疆");
			 boolean isempty = true;
			 for (String p : plist) {
				 if (location.contains(p)) {
					 result[0] = p;
					 result[1] = location.substring(p.length(), location.length());
					 isempty = false;
				 }
			 }
			 if (isempty) {
				 result[0] = location;
				 result[1] = "其他";
			 }
		 }
		 return result;
	 }
	 /**
	  * 获取符合预警值得结果
	  * */
	 public void warmResult(List<IMSIImportEntity> anasisList) {
		 try {
			 List<HotWarmImportEntity> warmList = wifiAndImsiImportService.getWarmInfo("3");//3:imsi实时预警，4：wifi实时预警5:imei实时预警
			 List<Map<String,Object>> resultList = new ArrayList<Map<String,Object>>();
			 for (IMSIImportEntity imsiImportEntity : anasisList) {
				 try{
					 for (HotWarmImportEntity hotWarmEntity : warmList) {
						 if (hotWarmEntity.getWarmvalue().equals(imsiImportEntity.getImsi()) || hotWarmEntity.getWarmvalue().equals(imsiImportEntity.getImei())) {
							 Map<String,Object> map = new HashMap<String,Object>();
							 map.put("id", hotWarmEntity.getId());
							 map.put("warmTime", imsiImportEntity.getStarttime());
							 map.put("siteId", imsiImportEntity.getWsiteid());
							 resultList.add(map);
						 }
					 } 
				 } catch(Exception e) {
					 e.printStackTrace();
				 }
			 }
			 wifiAndImsiImportService.insertWarmResult(resultList); 
		 } catch(Exception e) {
			 e.printStackTrace();
		 }
	 }
}
xiaogg3678
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在spring boot中使用java线程池ExecutorService的讲解
08-26
在 Spring Boot 中使用 Java 线程池 ExecutorService 的讲解 Spring Boot 作为一个流行的 Java 框架，提供了许多便捷的功能来帮助开发者快速构建应用程序。其中之一就是使用 Java 线程池 ExecutorService 来管理...
Java 线程池ExecutorService详解及实例代码
09-01
本文将详细讲解ExecutorService的原理、使用场景以及如何通过Executors类创建线程池。 1. 为什么使用线程池 线程池的主要目的是为了优化线程的生命周期管理。在处理大量并发任务时，如果每个任务都单独创建线程，...
详解Java利用ExecutorService实现同步执行大量线程
08-31
主要介绍了Java利用ExecutorService实现同步执行大量线程,ExecutorService可以维护我们的大量线程在操作临界资源时的稳定性。
java ExecutorService线程池技术实现批量导入数据
xiaogg3678的专栏
11-04 1050
Java利用线程池技术批量导入数据到数据库 ***1. 第一个类WifiAndImsiImportTask.java定时任务中组装集合数据并提交多线程池执行：*** /** * wifiImsi数据入库 * @author xjl * 2018-11-6 13:34:27 * */ @Component public class WifiAndImsiImportTask { private final int INSERNUM = 50000;//每次添加的条数 private fin
线程池的使用：批量导入、数据汇总、异步保存搜索记录
最新发布
llg___的博客
06-12 983
也可以使用CountDownLatch，线程池的线程每处理一个提交的任务，就让CountDownLatch减一（CountDownLatch初始化等待计数等于批次数），阻塞请求过来的那个线程，直到CountDownLatch减为0，最后统计下总耗时，返回给前端。在一个电商网站中，用户下单之后，需要查询数据，数据包含了三部分：订单信息、包含的商品、物流信息。搜索时，保存历史搜索记录。用户搜索一个keyword时，存历史搜索记录，不能影响到查询的性能，用异步去处理，将存历史记录的任务提交到线程池。
Java ExecutorService 多线程 | 使用线程池 批量处理 通用效验
qq_41497111的博客
07-19 1184
目录 看题： 要求： 解题： 先创建 三个 实体类。 ok, 此时需要对字段处理 效验，并有相应提示。 ok，接下来使用多线程批量处理。 ok，测试 输出结果 老司机开车，飙车有炫酷。多么迷人的idea。放张图镇镇场面。 看题： 备注：学生类 与 地址类 为一对一，学生类 与 电子产品类 为一对多。 要求： 多线程批量校验100多名学生信息，但是校...
java 批量插入clob_SpringBoot系列(16)线程池Executors并发编程之批量查询-插入数据
weixin_39818014的博客
12-02 271
在上篇文章中Debug给大家分享介绍了“Java线程池-多线程的其中一种应用场景~广播式给所有有效用户发送邮件(通知)”，本篇文章我们将继续向前迈进，继续介绍并实战“线程池-多线程的应用场景”，这一场景简称为“批量插入大量的数据”，同样是采用Java中的Executors下的其中某种线程池进行实战实现！“批量插入数据”这一业务场景在企业级应用开发中还是比较常见的，顾明思议，即“将给定的大批量的数据...
java多线程读取多个文件 导入数据库
热门推荐
xyr05288的专栏
10-14 1万+
近期在做java读文件的项目，由于数据量较大，因此研究了一下多线程，总结了一下：一. 多个线程读文件和单个线程读文件，效率差不多，甚至可能不如单线程，原因如下：如果只是单纯的读文件，一个线程足够了，因为一般瓶颈是在磁盘io上，多个线程只会在磁盘io上阻塞。因为不同文件的读写，会造成磁头的频繁转换，磁头的频繁转换要比读取磁盘的时间更长。但是一般是读一小块做一次处理，然后再读下一块，这样只用一个线程磁盘
java线程池实现批量下载文件
08-25
Java线程池实现批量下载文件是指使用Java语言和线程池机制来实现批量下载文件的功能。这种方法可以大幅提高下载速度和效率，特别是当需要下载大量文件时。下面将对Java线程池实现批量下载文件的原理和实现进行详细...
JAVA使用线程池查询大批量数据
05-09
Java中的线程池主要由`java.util.concurrent`包下的`ExecutorService`接口及其实现类提供。最常见的实现是`ThreadPoolExecutor`，它允许我们自定义线程池的核心参数，如核心线程数、最大线程数、线程存活时间等。...
Java ExecutorService四种线程池使用详解
08-28
Java的`java.util.concurrent`包中提供了`ExecutorService`的实现类，特别是通过`Executors`工厂类可以方便地创建四种类型的线程池，分别是`newCachedThreadPool`、`newFixedThreadPool`、`newScheduledThreadPool` ...
java多线程实现大批量数据导入源码
09-29
java多线程实现大批量数据切分成指定份数的数据，然后多线程处理入库或者导出，线程的个数和每份数据的数量都可以控制
java多线程方式导入excel数据入数据库
weixin_42982636的博客
11-26 3590
需求： 最近项目写了poi导入excel数据到数据库，在代码上已经算是很优了，虽然领导没有要求我优化导入接口，但是本着技术而言，想把学到的知识用于实践，于是使用多线程方式导入excel。 所需pow依赖: <dependency> <groupId>org.apache.poi</groupId> <artifactId>poi&lt...
Java 线程池框架技术批量插入数据库
xiaogg3678的专栏
11-05 1711
===GbGatewayGbTypeController控制器测试线程池对比类======== ===GbGatewayGbTypeController控制器测试线程池对比类======== ===GbGatewayGbTypeController控制器测试线程池对比类======== /** * 不用线程池单个插入 * @return */ @GetMapping("/noUseThreadsSingle") public R<Obj.
线程导入大数据入库_批量导入大数据表的时候 使用线程池处理
weixin_36212493的博客
01-14 279
public class UpdateMebinfoThread implements Runnable{private int beginnum= 0;// 开始行数private int endnum= 0;// 读取记录数public UpdateMebinfoThread(int beginnum, int endnum){super();this.beginnum= beginnum;t...
多线程19-线程池批量插入线程
weixin_30872499的博客
06-23 62
classProgram{staticvoidUseThreads(intnumberOfOperations){using(varcountdown=newCountdownEvent(numberOfOperations)){Console.Writ...
批量导入大数据表的时候 使用线程池处理
黄天霸的专栏
01-16 2972
public class UpdateMebinfoThread implements Runnable{ private int beginnum= 0;// 开始行数 private int endnum= 0;// 读取记录数   public UpdateMebinfoThread(int beginnum, int endnum)    {        supe
将数据批量插入数据库
lx1230的博客
06-27 227
核心代码展示： @Component public class AsyncExecutorPoolConfig { private static final Logger LOG = LoggerFactory.getLogger(AsyncExecutorPoolConfig.class); @Value("${peroninfo.async.log.queueSize:3...
【Java项目】SpringBoot项目的多文件兼多线程上传下载
Zhangsama1的博客
03-27 2319
SpringBoot实现多文件多线程上传下载
java 通过配置类配置Executor线程池ExecutorService ThreadPoolTaskExecutor配置
09-01
在Java中，可以使用配置类来配置Executor线程池。其中，常用的实现类是`ExecutorService`和`ThreadPoolTaskExecutor`。 首先，需要创建一个配置类，可以命名为`ThreadPoolConfig`或者其他你喜欢的名称。在这个类中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值