精华内容
下载资源
问答
  • java批次处理数据

    万次阅读 2019-06-28 10:48:58
    近期开发中 遇到 需要分批次处理数据问题,因此写了一段小demo来实现分批次处理,代码如下: public static void main(String[] args) { List<String> List = new ArrayList<String>(); for (int ...

    近期开发中 遇到  需要分批次处理数据问题,因此写了一段小demo来实现分批次处理,代码如下:


     public static void main(String[] args)  {
            List<String> List = new ArrayList<String>();
    
            for (int i = 0; i < 100; i++) { //假如如有一百单数据
                List.add("第" + (i+1) + "单");
            }
    
            int count = 20; //定义分批大小。即一批次20条
            List<String> newList = new ArrayList<String>(); //定义新的list 用于接收每次的值
    
            for (int i = 0; i < List.size(); i++) { //分批次处理
                newList.add(List.get(i));
    
                if ((count == newList.size()) || (i == (List.size() - 1))) {
                    //如果list的size=30 或者 刚好是全部数量(说明list数据循环完毕),因为上边从0开始,所以size-1,不然数组越界
                    for (int j = 0; j < newList.size(); j++) {
                        System.out.print(newList.get(j) + "   ");
                    }
    
                    System.out.println("批次处理");
                    newList.clear();
                }
            }
        }

    可直接复制运行查看效果

    展开全文
  • 主要介绍了Java利用ExecutorService实现同步执行大量线程,ExecutorService可以维护我们的大量线程在操作临界资源时的稳定性。
  • 1.在service层写java代码,进行分批 具体步骤写在了下面的代码里,注释也有。 //假设personList中有1200条数据 //一次500条,分num次插入,num为3。 int num = (personList.size() / 500)+1; //最后一次插入...

    其他链接:

    mysql模糊查询 like与locate效率
    https://blog.csdn.net/qq_33745371/article/details/106673790

    mybatis进行百万批量插入(我行),mysql进行百万批量插入(我不行)
    https://blog.csdn.net/qq_33745371/article/details/106630478

    mysql新建数据库字符集和排序规则
    https://blog.csdn.net/qq_33745371/article/details/106459524

    分批次批量插入

    假设我们的List<Person>集合一共有1200条数据。分批次,一次500条。
    Person类只有三个字段:id,name,age。

    1.在service层写java代码,进行分批

    具体步骤写在了下面的代码里,注释也有。

    
    //假设personList中有1200条数据
    //一次500条,分num次插入,num为3。
    int num = (personList.size() / 500)+1;
    //最后一次插入lastNumber条,取余数,lastNumber为200。
    int lastNumber = personList.size() % 500;
    //插入,会循环3次
    for(int i=0;i<num;i++){
    	//集合插入的起始位置
        int index = i*500;
        //集合插入的终止位置
        int end = (i+1)*500;
        //声明一个list集合,用于存放每次批量插入的数据
        List<Person> list;
        if(i==num-1){
    	    //subList(index, end),list集合的下标从0开始,[index,end) subList包含index,不包含end。
            //最后一次插入 subList(index, index+lastNumber)<==>subList(1000, 1200)
            list = personList.subList(index, index+lastNumber);
        }else{
        	//非最后一次插入 subList(index, end)<==>subList(500*i, 500*(i+1))
            list = personList.subList(index, end);
        }
        //调用dao层的批量插入方法
        personDAO.addPersonList(list);
    

    2.在dao层写接口

    //dao层接口
    int addObjectList(List<Object> list);
    

    3.在dao.xml写批量插入

    Person类只有三个字段:id,name,age。id为主键,自动递增,我们不需要写。
    数据库的表名:person。
    collection为传入的类型,这里我们传入的是list。
    item为当前元素。
    separator为分隔符

    //批量插入
        <insert id="addObjectList">
            insert into person(name,age) values
            <foreach collection="list" item="person" separator=",">
                (#{person.name},#{person.age})
            </foreach>
        </insert>
    
    展开全文
  • 接着前面那个案例,我们有一个file文件,里面有a b c d e f g h...执行main方法,即可实现题目所说效果,当然,实际处理逻辑中,不可能简单的输出每一行就可以了,肯定需要对每一行数据做相应业务逻辑处理。  

    接着前面那个案例,我们有一个file文件,里面有a b c d e f g h i j 一共10条数据,我们需要以4条为一批,分成3批处理,即第一批是a b c d,第二批数据是e f g h,第三批数据是i j,所以按照这样的逻辑,之前的思路是采用采用Map<Integer, List<TSSBBody>>方式装数据,有多少批数据,就有多少个键值对,至于List的size(),必然是4 4 2,期间遇到一个坑,解决了,后来经过效率测试,这样的逻辑处理,有些费时,10条数据可能看不出差异,但是上万的数据处理起来,竟然没有直接读取file文件效率快,那么,我们如何按批次处理这个file文件呢?

    既然要按照批次处理文件,我们首先肯定需要判断文件总的有多少行,然后再考虑多少行为一个批次,最后一个批次有多少行文件,那么,如何判断文件总的有多少行呢?我们可以用LineNumberReader,代码如下:

    // 文件内容的总行数
    	static int getTotalLines(File file) throws IOException {
    		FileReader in = new FileReader(file);
    		LineNumberReader reader = new LineNumberReader(in);
    		String s = reader.readLine();
    		int lines = 0;
    		while (s != null) {
    			lines++;
    			s = reader.readLine();
    		}
    		reader.close();
    		in.close();
    		return lines;
    	}

    接下来,我们就需要明确的是多少行为一个批次?最后一个批次多少行?确定好这些因素,循环处理每一批,这逻辑就实现了,但是这里需要确定一个方法,就是之前一篇文章所说过的,如何按固定行数处理文件,这里为了方便,贴下代码:

    // 读取文件指定行内容
    	static String readLineNumberString(File sourceFile, int lineNumber) throws IOException {
    		String s = null;
    		if (lineNumber < 0 || lineNumber > getTotalLines(sourceFile)) {
    			System.out.println("传入行数" + lineNumber + "有误,不在范围之内");
    		} else {
    			InputStreamReader inputReader = null;
    			BufferedReader bufferReader = null;
    			OutputStream outputStream = null;
    			try {
    				InputStream inputStream = new FileInputStream(sourceFile);
    				inputReader = new InputStreamReader(inputStream, "UTF-8");
    				bufferReader = new BufferedReader(inputReader);
    
    				// 读取一行
    				String lineContent = null;
    				StringBuffer strBuffer = new StringBuffer();
    				int currentReadLine = 0;
    				while ((lineContent = bufferReader.readLine()) != null) {
    					currentReadLine++;
    					if(currentReadLine==lineNumber){
    						strBuffer.append(lineContent);
    						break;
    					}
    				}
    				s = strBuffer.toString();
    			} catch (IOException e) {
    				System.out.println("" + e.getMessage());
    			} finally {
    				IOCloseUtil.closeAll(outputStream, bufferReader, inputReader);
    			}
    		}
    		return s;
    	}
    public static void main(String[] args) {
    		String fileName = "1.txt";
    		File file = new File("E:\\ceshi\\" + fileName);
    		try {
    			int sum = 10; //总行数--调用getTotalLines()方法即可
    			int pi = 4; //多少行为一个批次
    			int sumPi = (int) Math.ceil((double) 10 / 4); //分多少个批次
    			System.out.println("一共分" + sumPi + "个批次");
    			for (int i = 0; i < sumPi; i++) {
    				Integer batch_total_no = 4;
    
    				// 如果是最后一页,这一页的数据量为余数
    				if (i + 1 == sumPi && sum % 4 > 0) {
    					batch_total_no = sum % 4;
    				}
    
    				System.out.println("正在处理第" + (i + 1) + "个批次");
    				for (int j = 1; j <= batch_total_no; j++) {
    					if (i == sumPi) {
    						break;
    					} else {
    						String aa = readLineNumberString(file, i * pi + j);
    						System.out.println((i * pi + j) + "===" + aa);
    					}
    				}
    			}
    
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}

    执行main方法,即可实现题目所说效果,当然,实际处理逻辑中,不可能简单的输出每一行就可以了,肯定需要对每一行数据做相应业务逻辑处理。

     

    展开全文
  • Java List 分批执行

    2020-12-28 20:36:34
    但是目前发现List 数量过大导致单次拼接的SQL特别大,结果是拼接了SQL执行了大半天也没有执行完成。因此考虑到使用subList来给这个大 List 做个拆分,于是有了下面的代码。 public static void main(String[] args) ...

    最近在做一个批处理插入,需要对一个 List 中的数据通过批处理的方式插入到数据库当中去。但是目前发现List 数量过大导致单次拼接的SQL特别大,结果是拼接了SQL执行了大半天也没有执行完成。因此考虑到使用subList来给这个大 List 做个拆分,于是有了下面的代码。

    public static void main(String[] args) {
        int limit = 10;
        for (int j = 0; j < 10000; j++) {
            // 测试生成随机的 List 的 size
            int size = new Random().nextInt(1000000000);
            int count = (int) Math.ceil(size / (double) limit);
            // 校验最后一批数据是否在 list 的序号区间中
            int i = count - 1;
            final int from = i * limit;
            final int to = Math.min(size, (i + 1) * limit);
            System.out.printf("current form : %d  , to %d . %n", from, to);
            // 校验是否能够符合逻辑
            Assert.assertTrue(from<to);
            System.out.printf("size : %d.%n", size);
        }
    }
    

    这里的代码主要是用来做测试使用的,技术难点在于如何设置分批,然后循环。

    // 根据 List 的 size 和 每批的数量获取总共需要执行的批次
    int count = (int) Math.ceil(size / (double) limit);
    

    这里是通过’总数/每批的数量’来获取需要执行的批次,但如上面所示,当两个整数相除时,得到的是没有余数的上。这样会导致一个问题,也即我们计算得到的批次可能会比我们实际要执行的批次少一次。

    如当我们共有 55 条数据,每批为 10 条时,我们如果直接用 ‘总数/每批的数量’,取得执行批次为5;当我们同样有50条数据,每批为10条时,同样取得批次为5,这样的话就会少执行一批数据。如下面代码所示:

    public static void main(String[] args) {
        int limit = 10;
        int size = 55;
        int batch = size/limit;
        for(int i = 0;i < batch;i++){
        	// 这样编写代码会发现少执行一批数据,
        	//当为<=时则又会在数量为整除时多执行一批数据从而导致
        	// IndexOutBoundException
        	System.out.printf("from index %d to index %d%n",i*limit,(i+1)*limit);
    	}
    }
    

    通过转换成浮点数计算的方式可以在由于余数的时候通过向上取整的方式多执行一批,然后通过下面代码来避免数组越界问题,即可完美解决分批问题。

    final int to = Math.min(size, (i + 1) * limit);
    

    完整的分批逻辑如下:

    public static void main(String[] args) {
      int limit = 10;
      // 测试生成随机的 List 的 size
      int size = 55;
      int count = (int) Math.ceil(size / (double) limit);
      List<String> list = new ArrayList<>(size);
      for(int i = 0;i < count;i++){
         final int from = i * limit;
    	 final int to = Math.min(size, (i + 1) * limit);
    	 System.out.printf("current form : %d  , to %d . %n", from, to);
    	 List<String> subList = list.subList(from,to);
    	 // do your batch code
      }
    }
    
    展开全文
  • 我是使用的java线程池ThreadPoolExecutor,实现分批次去查询,查询到数据后,又分多个线程去做业务。 线程池类为 java.util.concurrent.ThreadPoolExecutor,常用构造方法为:ThreadPoolExecutor(int corePoolSize,...
  • java批次处理大数据量数据

    千次阅读 2020-01-08 09:29:06
    业务难点:A库中表的数据量比较大,50W数据(相对意义大数据量),单纯select * from table 查询时间很长,而且容易内存溢出,并且数据清洗完插入B库中效率也是很慢的,我这里采取分批次处理,并且采用线程池 多线程处理数据 ...
  • java动态执行while循环

    2019-07-25 16:56:43
    问题描述: ... //执行econd秒后退出while循环 } } 实现思路: 设置一个定时器执行定时任务,到达指定时间后把flag的值设置成false 代码 import java.util.Timer; import java.util.TimerTask...
  • 各位大佬,只有一个任务,但是数据量大,所以要分批次执行,有没有什么解决方案呢 列如:1第一个线程跑前10条数据 2第二个跑中间1条,依次内推,有啥好的解决方式吗
  • java批量执行之分批处理

    千次阅读 2018-09-15 15:42:16
    在处理一些与数据库相关的操作的时候,通常把一些操作合并能够起到优化的效果,并且数量越大,批量执行的效率比一条一条执行的效率要快的多。 批量插入比单次插入快 比如有十条数据单条执行需要操作十次数据库,...
  • JAVA 分割集合 多线程 分批次操作 分割集合工具类(我还写了一个更全面的的工具类可以了解一下) https://blog.csdn.net/Mclaughling/article/details/113247668 /** * 将一组数据平均分成n组 * @param source 要...
  • java-服务下线时需要执行方法, 如断开数据库连接,zk连接… 1. 实现DisposableBean接口 说明: 实现DisposableBean接口, destroy方法就是服务关闭执行的方法 配置关闭服务执行方法:package com.luck.config; import...
  • java多线程实现大批量数据切分成指定份数的数据,然后多线程处理入库或者导出,线程的个数和每份数据的数量都可以控制
  • Mysql load data的使用,MySQL的LOAD DATAINFILE语句用于高速地从一个文本文件中读取行,并装入一个表中
  • groupingBy批次分组数据 使用groupingBy根据每个批次的大小,将数据拆分成多组数据。 55条数据,按每个批次10条拆分出6组数据。 样例代码 List<String> list = new ArrayList<String>(); for (int i=1...
  • JavaPOI分批次读取Excel,彻底避免OOM

    万次阅读 2018-08-27 18:41:04
    3. 对于写完的文件,就好办了,我们可以用Java自带的IO流分批次去读取数据,这样,无论多大的文件就都不会出现内存溢出问题了。 4. 当然,对于上面的读取方式,事实上如果我们想在程序里面使用这个数据,那只能是...
  • java poi分批次导入Excel

    2019-10-06 16:45:47
    最近换了新工作,公司要求导入Excel要分批次导入,并且是多线程的情况下执行导入,查了很多资料,没看到比较复合的,就打算自己写一个吧,可能有不足,希望指出。 上面说到多线程,这边就不贴出代码了,具体思路...
  • Java实现多个线程一起并发执行

    千次阅读 2020-10-20 16:45:33
    面试人员:用Java的多线程模拟一个赛马,马场上有10匹马,要求他们同时起跑 设计到的Java多线程技术:CountDownLatch或者CyclicBarrier /** * <p> * <p>Title:testCountDownLatch.java</p > ...
  • 使用JDBC连接MySQL数据库进行数据插入的时候,特别是大批量数据连续插入(100000),如何提高效率呢?...不过值得注意的是,首先需要在数据库链接中设置手动提交,connection.setAutoCommit(false),然后在执行S...
  • 批次号/订单号生成

    千次阅读 2018-02-22 08:49:54
    在系统内部或与其他系统进行对接对编码有一定自定义规则,包括批次号、订单号,比如 PCH20170727152245000001 编码规范 = 开头字母 + 年月日时分秒 + 序号 ,使用存储过程和不使用存储过程两种方式,数据都是存在 ...
  • java多线程分批执行任务demo

    千次阅读 2020-04-28 15:01:07
    利用线程池实现线程分批执行任务。 例如:线程池容量为10,我有20个任务,第一次利用线程池中的10个线程异步执行完10个任务。10个任务完成后,不管任务成功或者失败,线程池回收10个线程继续完成剩下10个任务。 ...
  • 对于我的Java项目,我越来越需要使用数据库,因此我认为手头有一个类似的工具很有意义,该工具可以让我轻松地创建然后运行迁移而无需太多样板代码。 我发现的其他Java迁移工具不太符合我的需求,因此我决定编写自己...
  • Java线程池并发执行多个任务

    千次阅读 2019-10-12 13:38:32
    把任务本身和任务的执行解耦了,如果说Runnable是可异步执行任务的抽象,那Executor就是如何执行可异步执行任务的抽象,说起来比较绕口。 本文不讲解线程的一些基础知识,因为网上的其他文章已经写的足够详细和泛滥...
  • java分批处理小算法

    千次阅读 2019-02-21 10:58:32
    // 一个批次的数量 List&lt;Object&gt; tmpList = new ArrayList&lt;&gt;(); // 储存一个批次的数据 for (int i = 0; i &lt; sum; i++) { tmpList.add(list.get(i)); // 储存数据 ...
  • 1.2.1 消息和批次 1.2.2 主题和分区 1.2.3 生产者和消费者、偏移量、消费者群组 1.2.4 Broker和集群 1.2.5 保留消息 02 为什么选择kafka 2.1 优点 2.2 常见场景 2.2.1 活动跟踪 2.2.2 传递消息 2.2.3 收集指标和...
  • 这是Windows的简单可执行文件,可以轻松更改用户的文件名批次。 功能性 该程序允许用户: 选择文件夹的目录,或使用可执行文件所在的当前目录 查看将要更改的文件 在提交更改之前先预览更改。 从文件的开头和/或...
  • 代码如下所示,将 /Users/shiheng/desktop/测试文件 目录下的图片(包含子文件夹目录下的图片)移动到了 /Users/shiheng/desktop/测试结果 目录下,默认不分批次建立文件夹,重名文件只保存一个: package ...
  • Java 数据分批调用接口的正确姿势

    千次阅读 多人点赞 2019-09-26 00:41:40
    比如List参数的size可能为 几十个甚至上百个,但是假如对方dubbo接口比较慢,传入50个以上会超时,那么可以每次传入20个,分批执行。 通常很多人会写 for 循环或者 while 循环,非常不优雅,无法复用,而且容易出错...
  • java8 看不到源码 Ooso 允许您以无服务器方式运行 MapReduce 作业。 它基于托管云服务,主要是标准临时查询和批处理工具(如 和 )的替代品。 目录 一、架构和工作流程 库工作流程如下: 工作流首先调用Mappers ...
  • 这是一款开源一年多 GitHub star 2 万,99% 的阿里研发小哥都在用的 Java 终极诊断利器!相对比直接下载使用,我推荐开发者可以试一下通过 IDE插件 Cloud Toolkit 中使用Arthas 来实现一键远程诊断功能。 得益于 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,169
精华内容 5,267
关键字:

java批次执行

java 订阅