精华内容
下载资源
问答
  • 1.组装数据:CountDownLatch多线程分页查询组装数据 @Override public Map<String, Object> exportBmInformationMainModelList(Map<String, Object> queryParams) { List<List<Object>>...

    1.组装数据:CountDownLatch多线程分页查询组装数据

    @Override
        public Map<String, Object> exportBmInformationMainModelList(Map<String, Object> queryParams) {
             List<List<Object>> data = new ArrayList<List<Object>>(); // 需要导出的数据
             
            BmInformationMainQueryCondition condition = new BmInformationMainQueryCondition();
            if (null == queryParams.get("businessOrderTypeNo")) {
                return new HashMap<String, Object>();
            }
            if(queryParams.get("infoMainNo")==null ||queryParams.get("infoMainNo").toString().equals("null")){
                queryParams.remove("infoMainNo");
            }
            BeanToMapUtils.mapToBean(queryParams, condition);
            
            BmBusinessDetailQueryCondition detailCondition=new BmBusinessDetailQueryCondition();
            detailCondition.setOrgId(condition.getOrgId());
            detailCondition.setOrderTypeNo(condition.getBusinessOrderTypeNo());
            List<BmBusinessDetailQueryItem> businessDetailQueryItems=bmBusinessDetailManager.getBusinessDetail(detailCondition);
    
            ArrayList title=new ArrayList<List<String>>();
            List<String> headCell1 = new ArrayList<String>();
            headCell1.add("单据编号");
            title.add(headCell1); //表头
            List<String> headCell2 = new ArrayList<String>();
            headCell2.add("经营组织");
            title.add(headCell2);
            List<String> headCell3 = new ArrayList<String>();
            headCell3.add("客户名称");
            title.add(headCell3); //表头
            List<String> headCell4 = new ArrayList<String>();
            headCell4.add("供应商名称");
            title.add(headCell4); //表头
            List<String> headCell5 = new ArrayList<String>();
            headCell5.add("品牌");
            title.add(headCell5); //表头
            List<String> headCell6 = new ArrayList<String>();
            headCell6.add("运单号");
            title.add(headCell6); //表头
            List<String> headCell7 = new ArrayList<String>();
            headCell7.add("VIN码");
            title.add(headCell7); //表头
            List<String> headCell8 = new ArrayList<String>();
            headCell8.add("起始地");
            title.add(headCell8); //表头
            List<String> headCell9 = new ArrayList<String>();
            headCell9.add("目的地");
            title.add(headCell9); //表头
            List<String> headCell10 = new ArrayList<String>();
            headCell10.add("业务类型");
            title.add(headCell10); //表头
            List<String> headCell11 = new ArrayList<String>();
            headCell11.add("状态");
            title.add(headCell11); //表头
            List<String> headCell12 = new ArrayList<String>();
            headCell12.add("是否计费");
            title.add(headCell12); //表头
            List<String> headCell13 = new ArrayList<String>();
            headCell13.add("运抵时间");
            title.add(headCell13); //表头
            List<String> headCell14 = new ArrayList<String>();
            headCell14.add("业务日期");
            title.add(headCell14); //表头
    
            ArrayList<String> otherAttributeList=new ArrayList<String>();
            if(businessDetailQueryItems.size()>0){
                for(BmBusinessDetailQueryItem item:businessDetailQueryItems){
                    if(!title.contains(item.getAttNameCn())){
                        List<String> headCell = new ArrayList<String>();
                        headCell.add(item.getAttNameCn());
                        title.add(headCell); // 表头
                        otherAttributeList.add(item.getAtt());
                    }
                }
            }
            List<String> headCell15 = new ArrayList<String>();
            headCell15.add("来源系统业务单号");
            title.add(headCell15); //表头
            
            List<String> headCell16 = new ArrayList<String>();
            headCell16.add("客户订单号");
            title.add(headCell16); //表头
            
            List<String> headCell17 = new ArrayList<String>();
            headCell17.add("会计主体");
            title.add(headCell17); //表头
            
            List<String> headCell18 = new ArrayList<String>();
            headCell18.add("创建时间");
            title.add(headCell18); //表头
            
            BigInteger rowNum=new BigInteger("0");
            int times=0;
            List<Map<String, Object>> bmInformationMainRumNum=calculateCommonService.nativeSqlFind("QueryBmInformationMainCount",null,queryParams);
            if(bmInformationMainRumNum.size()>0){
                rowNum=(BigInteger) bmInformationMainRumNum.get(0).get("rowNum");
            }
            if(rowNum.longValue()>0){
                times=(int) Math.ceil((double)rowNum.doubleValue()/(double)10000);
                final CountDownLatch barrier=new CountDownLatch(times);
                for(int i=0;i<times;i++){
                    Map map=new HashMap();
                    map.putAll(queryParams);
                    map.put("startNum", i*10000);
                    new QueryBmInformationMainThread(barrier,otherAttributeList, data, map).start();
                }
                try {
                    barrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
            Map<String, Object> result = new HashMap<String, Object>();
            result.put("headList", title);
            result.put("dataList", data);
            return result;
        }

    2.分页查询线程

        

    class QueryBmInformationMainThread extends Thread{
            private CountDownLatch  countDownLatch ;
            private ArrayList<String> otherAttributeList;
            private List<List<Object>> data;
            private Map<String, Object> queryParams;
            
            public QueryBmInformationMainThread(CountDownLatch countDownLatch, ArrayList<String> otherAttributeList,List<List<Object>> data,Map<String, Object> queryParams){
                this.otherAttributeList=otherAttributeList;
                this.data=data;
                this.queryParams=queryParams;
                this.countDownLatch=countDownLatch;
            }
            
            @Override
            public void run() {
                List<Map<String, Object>> thisTimesList=calculateCommonService.nativeSqlFind("QueryBmInformationMainList",null,queryParams);
                List<List<Object>> thisResult=new ArrayList<List<Object>>();
                if (thisTimesList.size() > 0) {
                    for (Map<String,Object> item : thisTimesList) {
                         ArrayList<Object> info=new ArrayList<Object>();
                         info.add(item.get("INFO_MAIN_NO"));
                         info.add(item.get("COMPANY_NAME"));
                         info.add(item.get("CUST_NAME"));
                         info.add(item.get("SUP_NAME"));
                         info.add(item.get("ATTRIBUTE_018"));
                         info.add(item.get("ATTRIBUTE_002"));
                         info.add(item.get("ATTRIBUTE_003"));
                         info.add(item.get("ATTRIBUTE_010"));
                         info.add(item.get("ATTRIBUTE_012"));
                         if(item.get("BUSINESS_TYPE")!=null && item.get("BUSINESS_TYPE").equals("TRANSPORT")){
                             info.add("运输");
                         }
                         else if(item.get("BUSINESS_TYPE")!=null && item.get("BUSINESS_TYPE").equals("STORAGE")){
                             info.add("仓储");
                         }
                         if(item.get("SUBMIT_STATUS")!=null && item.get("SUBMIT_STATUS").equals("submit")){
                             info.add("审核");
                         }
                         else if(item.get("SUBMIT_STATUS")!=null && item.get("SUBMIT_STATUS").equals("cancel")){
                             info.add("未审核");
                         }
                         if(item.get("IS_COMPLETE_CALC")!=null && item.get("IS_COMPLETE_CALC").equals("Y")){
                             info.add("是");
                         }
                         else if(item.get("IS_COMPLETE_CALC")!=null && item.get("IS_COMPLETE_CALC").equals("N")){
                             info.add("否");
                         }
                         info.add(item.get("ATTRIBUTE_006"));
                         //业务日期格式化年月日
                         SimpleDateFormat ymd =new SimpleDateFormat("yyyy-MM-dd" );
                         info.add(ymd.format(item.get("BUSINESS_TIME")));
                         for(String attr:otherAttributeList){
                             info.add(item.get(humpToUnderline(attr)));
                         }
                         
                         info.add(item.get("BUSINESS_SOURCE_NO"));
                         info.add(item.get("CUST_ORDER_NO"));
                         info.add(item.get("LEGAL_ENTITY_NAME"));
                         //业务日期格式化年月日
                         SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss" );
                         info.add(sdf.format(item.get("CREATE_TIME")));
                         thisResult.add(info);
                    }
                }
                synchronized(data){
                    data.addAll(thisResult);
                }
                countDownLatch.countDown();
            }
            
        }

    3.EasyExcel导出

    @ResponseBody
        @RequestMapping(value = "/exportBusinessOrderInfoExcel")
        public void exportBusinessOrderInfoExcel(@RequestParam Map<String, Object> params) throws Exception{
            if(null == params.get("businessOrderTypeNo")||"".equals(params.get("businessOrderTypeNo"))){
                return;
            }
            params.put("orgId", UserContextHolder.getCurrentUser().getOrgId());
            
            Map<String, Object> result = bmBusinessOrderInfoService.exportBmInformationMainModelList(params);
            if (EmptyUtils.isEmpty(result)) {
                return;
            }
            List<List<String>> headerList = (List<List<String>>) result.get("headList"); // 需要导出的数据
            List<List<Object>> dataList = (List<List<Object>>) result.get("dataList"); // 需要导出的数据
            DateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
            String date = df.format(new Date());
            String excelName = "业务单据" + date + ".xlsx";
            String sheetName = "业务单据";
            excelName = URLEncoder.encode(excelName, "UTF-8");
            HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
            ServletOutputStream out = response.getOutputStream();
            response.setCharacterEncoding("UTF-8");
            response.addHeader("Content-Disposition", "attachment;filename=" + excelName);
            response.setContentType("application/vnd.ms-excel");
            
            
            ExcelWriter writer = EasyExcelFactory.getWriter(out);
            // 写在sheet1
            Sheet sheet1 = new Sheet(1, 3);
            sheet1.setSheetName(sheetName);
            sheet1.setHead(headerList);
            // or 设置自适应宽度
            sheet1.setAutoWidth(Boolean.TRUE);
            writer.write1(dataList, sheet1);
            writer.finish();
            out.flush();
            out.close();
        }

     

    展开全文
  • java多线程分页查询

    热门讨论 2011-04-22 12:13:13
    用于数据量大的情况下预先查询出数据,加快对后面页面数据的查询速度
  • Java多线程分页查询

    千次阅读 2019-07-01 15:11:17
    "开启多线程查询导出数据耗时:{},共:{}条" , ( end - start ) , result . size ( ) ) ; } return result ; } public class ThredQuery implements Callable < List < UserQueryDTO > > ...

    提示:JVM堆内存配置低.存在内存溢出.
    代码:

    public List<UserQueryDTO> getResult(UserQuery userQuery) throws Exception {
            long start = System.currentTimeMillis();
            //返回结果
            List<UserQueryDTO> result = new ArrayList<>();
    
            // 通过count查到数据总量
            int count = userService.listUserExportCount(userQuery);
    
            int num = 2000;//每次查询的条数
            //需要查询的次数
            int times = count / num;
            if (count % num != 0) {
                times = times + 1;
            }
            //开始查询的行数
            int bindex = 0;
            //添加任务
            List<Callable<List<UserQueryDTO>>> tasks = new ArrayList<Callable<List<UserQueryDTO>>>();
            for (int i = 0; i < times; i++) {
                Callable<List<UserQueryDTO>> qfe = new ThredQuery(userService, userQuery, bindex, num);
                tasks.add(qfe);
                bindex = bindex + num;
            }
            //定义固定长度的线程池  防止线程过多
            ExecutorService execservice = Executors.newFixedThreadPool(15);
    
            List<Future<List<UserQueryDTO>>> futures = execservice.invokeAll(tasks);
            // 处理线程返回结果
            if (CollectionUtils.isNotEmpty(futures)) {
                for (Future<List<UserQueryDTO>> future : futures) {
                    result.addAll(future.get());
                }
            }
            // 关闭线程池
            execservice.shutdown();
    
            long end = System.currentTimeMillis();
            if (log.isInfoEnabled()) {
                log.info("开启多线程查询导出数据耗时:{},共:{}条", (end - start), result.size());
            }
            return result;
        }
    
    public class ThredQuery implements Callable<List<UserQueryDTO>> {
    
        private IUserQueryService userService;//需要通过够早方法把对应的业务service传进来 实际用的时候把类型变为对应的类型
        private UserQuery userQuery;//查询条件 根据条件来定义该类的属性
    
        private int bindex;//分页index
        private int num;//数量
    
        /**
         * 重新构造方法
         *
         * @param userService
         * @param userQuery
         * @param bindex
         * @param num
         */
        public ThredQuery(IUserQueryService userService, UserQuery userQuery, int bindex, int num) {
            this.userService = userService;
            this.userQuery = userQuery;
            this.bindex = bindex;
            this.num = num;
        }
    
        @Override
        public List<UserQueryDTO> call() throws Exception {
            //通过service查询得到对应结果
            List<UserQueryDTO> list = new ArrayList<>();
            userQuery.setStart(bindex);
            userQuery.setLimit(num);
            list = userService.listUserExport(userQuery);
            return list;
        }
    }
    
    展开全文
  • Spring boot 多线程 分页查询 合并结果

    千次阅读 2018-11-26 20:25:17
    mysql 要使用 in 查询,in 的List比较大,多线程分解List查询 public List&lt;UserCountBiz&gt; getAttendByPageList(List&lt;Long&gt; list, int pageSize) throws Exception { int ...

    mysql 要使用 in 查询,in 的List比较大,多线程分解List查询

     public List<UserCountBiz> getAttendByPageList(List<Long> list, int pageSize) throws Exception {
    
            int totalCount = list.size();
            int m = totalCount % pageSize;
            int pageCount = m == 0 ? (totalCount / pageSize) : (totalCount / pageSize + 1);
    
            List<UserCountBiz> resultList = new ArrayList<>();
            BlockingQueue<Future<List<UserCountBiz>>> queue = new LinkedBlockingQueue();
    
            for (int i = 1; i <= pageCount; i++) {
                Thread.sleep(0);
                Future<List<UserCountBiz>> future;
                if (m == 0) {
                    List<Long> subList = list.subList((i - 1) * pageSize, pageSize * (i));
                    future = getAttendCountSubList(subList);
                } else {
                    if (i == pageCount) {
                        List<Long> subList = list.subList((i - 1) * pageSize, totalCount);
                        future = getAttendCountSubList(subList);
                    } else {
                        List<Long> subList = list.subList((i - 1) * pageSize, pageSize * (i));
                        future = getAttendCountSubList(subList);
                    }
                }
                queue.add(future);
            }
    
            int queueSize = queue.size();
            log.debug("queue size:" + queueSize);
            for (int i = 0; i < queueSize; i++) {
                List<UserCountBiz> subAttendList = queue.take().get();
                if (!CollectionUtils.isEmpty(subAttendList)) {
                    resultList.addAll(subAttendList);
                }
            }
            return resultList;
        }
    
    

    先将List分解成小subList,再执行mysql 的in(List),将结果future放入阻塞队列,然后合并。

    Future 方法:

        @Async
        public Future<List<MiniClassLessonUserCountBiz>> getAttendCountSubList(List<Long> subList) throws Exception {
            List<MiniClassLessonUserCountBiz> subAttendList = recordService.getUserAttendCount(subList);
            log.info("完成任务");
            return new AsyncResult<>(subAttendList);
        }

    Spring Boot 使用@Async注解在异步方法上,使用@EnableAsync 注解在Spring Application主类上。

    展开全文
  • 一、由于具有张宽表且字段较,每个宽表数据大概为4000万条,...由于下来要进行分页查询,如果要使用SparkSQL进行分页查询,需要增加序号列,那么就在刚才的Sql之前增加一句 create table tableName as SELECT ROW

    一、由于具有多张宽表且字段较多,每个宽表数据大概为4000万条,根据业务逻辑拼接别名,并每张宽表的固定字段进行left join 拼接SQL。这样就能根据每个宽表的主列,根据每个宽表的不同字段关联出一张新的集合。由于下来要进行分页查询,如果要使用SparkSQL进行分页查询,需要增加序号列,那么就在刚才的Sql之前增加一句 create table tableName as SELECT  ROW_NUMBER() OVER() as id,* from (拼接的SQL) 就可创建一张带自增序列的,业务需要字段的几张宽表的关联集合,方便下来分页。

    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
    37
    for ( int  i= 0 ;i<ColumnNames.size();i++){
                 SiCustomerLabelInfoModel Column = ColumnNames.get(i);
                 List<CiMdaSysTable> ciMdaSysTable = ciCustomerJDao.getMdaSysTableName(Column.getColumnName());
                 
                 String alias =  "t_"  + ciMdaSysTable.get( 0 ).getTableId();
                 String aliasColumn = alias +  "."  + Column.getColumnName();
                 String aliasTable = ciMdaSysTable.get( 0 ).getTableName() + " " + alias;
                 
                 if (mainTable ==  null ){
                     mainTable = aliasTable;
                 }
                 if (ciMdaSysTable.get( 0 ).getUpdateCycle() ==  1 ){
                     mainTable = aliasTable;
                 }
                 
                 ColumnNameList.add(aliasColumn);
                 tableNameList.add(aliasTable);
             }
             String[] keyAlias = mainTable.split( " " );
             String mainKeyColumn = keyAlias[ 1 ] +  "."  + keyColumn;
             selectResult.append( "select " ).append(mainKeyColumn);
             if (StringUtil.isNotEmpty(mainTable)){
                 fromTableName.append( " from " ).append(mainTable);
             }
             Iterator<String> table = tableNameList.iterator();
             while (table.hasNext()){
                 String tableName = table.next();
                 String[] tableAlias = tableName.split( " " );
                 String[] mainAlias = mainTable.split( " " );
                 String alias = tableAlias[ 1 ];
                 String mAlias = mainAlias[ 1 ];
                 
                 if (!mainTable.equals(tableName)){
                 fromTableName.append( " left join " ).append(tableName).append( " on " ).append(mAlias).append( "." ).append(keyColumn)
                 .append( " = " ).append(alias).append( "." ).append(keyColumn).append( " " );
                 }
             }<br>        

              fromTableName.append(" ) a");
              Iterator<String> column = ColumnNameList.iterator();
              while(column.hasNext()){
              String columnName = column.next();
              selectResult.append(",").append(columnName);
              }
              selectResult.append(fromTableName);
              Createtable.append("create table ").append(cocDwName).append(" as SELECT ROW_NUMBER() OVER() as id,* from").append(" (").append(selectResult);

    1
    <br>

    二、由于业务场景,需要将4000万条数据最终写入10个文件,这里通过声明线程池pool,使用多线程的方法执行,有些人会担心那不会数据错乱吗,不会。因为后面要用分页sql,根据循环传入的 i 的值进行处理。

    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
    37
    38
    39
         private  ExecutorService pools = Executors.newFixedThreadPool( 15 );
    if (result =  true ){
                 String queryCount =  "select count(*) from " +cocDwName;
                 int  count = ciCustomerJDao.getDwTotolCount(queryCount);
                 log.info( "" +keyColumn);
                     try  {
                         for ( int  i= 0 ;i< 10 ;i++){
                             CreateDwFileThread jd =  new  CreateDwFileThread(jndiName,keyColumn,num,cocDwName,count,sysId,i);
                             Future fu = pools.submit(jd);
                             fus.add(fu);
                         }
                         long  start = System.currentTimeMillis();
                         while  ( true ) {
                             boolean  done =  true ;
                             for  (Future f : fus) {
                                 if  (!f.isDone()) {
                                     done =  false ;
                                     break ;
                                 }
                             }
                             if  (!done) {
                                 try  {
                                     Thread.sleep( 1000  10 );
                                 catch  (InterruptedException e) {
                                     log.error( "sleep error" , e);
                                     e.printStackTrace();
                                 }
                                 continue ;
                             else  {
                                 break ;
                             }
                         }
                         log.debug( "wait tasks finish cost:"  + (System.currentTimeMillis() - start));
                         
                         } catch (Exception e){
                             result =  false ;
                             log.error( "error" , e);
                         }
                     }

    三、根据第一步创建的表中的自增序列ID进行分页,由于要多线程并发执行,所以不能使用传统分页的begin与end,根据步骤二中传入的 i (这里参数为partNumber)进行处理,根据循环,每条线程执行的开始数据必定以上条数据结束的条数为开始,每次将查询出来的结果集通过list2File写入文件。这里还有个while循环,因为分成10份还是有400万条数据啊,还是觉得大,于是就又分成了10次~就是说每次查询出40万条写入文件,直到新加入400万条flag返回true退出循环。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    while (flag ==  false ){
             pager.setPageSize(bufferedRowSize);
             pager.setPageNum(pageNumber);
             
             int  begin = (pager.getPageNum() -  1 ) * pager.getPageSize()+createFileCount*partNumber;
             int  end = begin + pager.getPageSize();
             if (end >= createFileCount*(partNumber+ 1 )){
                 end = createFileCount*(partNumber+ 1 );
             }
             StringBuffer sql =  new  StringBuffer() ;
             sql.append( " select " ).append(columns).append( " from " ).append(cocDwName).append( " where id > " ).append(begin).append( " and " ).append( " id < " ).append(end+ 1 );
             JdbcBaseDao jdbcBaseDao = (JdbcBaseDao) SystemServiceLocator.getInstance().getService( "jdbcBaseDao" );
             String BackjndiName = PropertiesUtils.getProperties( "JNDI_CI_BACK" );
             final  String file = fileLocalPath + File.separator + dwName+  "_"  + String.valueOf(partNumber)+  ".csv" ;
             Log.info( "---------sql;:" + sql +  "-------fileName:" +file);<br><br>

                  

    1
    2
    3
    4
    5
    6
    7
    8
    List<Map<String, Object>> dataList = jdbcBaseDao.getBackSimpleJdbcTemplate().queryForList(sql.toString());
                   if  (dataList.size() >  0 ) {
                  list2File(dataList, title, columns, file, encode,  null null );
                  pageNumber++;
                  }
                   if (end == createFileCount * partNumber + createFileCount){
                  flag =  true ;
                  }

      

    有人会问你为啥不用ResultSet 直接放入400万条数据 为啥还要分开每40万条数据再分页写~ 我想说 我就是想这么干~ 啊哈哈。。。不过程序中貌似是有问题的 没有考虑到的情景,所以还在推敲。。(Resultset 查出来400万条不还是放在内存中,还是有可能内存溢出的,分页写大不了通过thriftserver多连接几次spark嘛~ 不过代码写的很烂,还在提高哈~)

    展开全文
  • ... import org.springframework.stereotype.Component; import java.util.ArrayList;... logger.info("改造多线程查询总耗时...{}",System.currentTimeMillis() - start); return result; }  
  • 多线程分页算法

    千次阅读 2012-07-16 16:44:03
    以下是多线程分页算法的具体实现,需要的可以试一下 /** * 多线程运行时的分页算法 */ @Test public void testThreadForPage(){ int allPage = 18; //总页数 int allThread = 5; //总共要启动的...
  • 基于EasyExcel多线程分页导出excel

    千次阅读 2020-05-31 00:39:34
    基于EasyExcel多线程分页导出excelMaven依赖线程池配置导出代码 第七更,基于EasyExcel 多线程分页导出excel 在项目中,BA要求全量导出表中数据,估计有十几万条,同事使用的是EasyPoi导致内存泄漏,我帮他优化,...
  • java使用多线程分页查询数据量很大的数据

    万次阅读 热门讨论 2018-07-24 14:59:18
    先通过count查出结果集的总条数,设置每个线程分页查询的条数,通过总条数和单次条数得到线程数量,通过改变limit的下标实现分批查询。   调用方法: import org.springframework.beans.factory.annotation....
  • 大家可以百度多线程分页关键字。我在网上找不到合适的解决方案或者能直接使用的代码,于是自己捣鼓了一个,但是只支持两个线程。废话不多说上代码。 import io.swagger.annotations.ApiModelProperty; import lombok...
  • int nums = 5000; int count = pubBookService.getBookExportCount(params); int thrednum = (count % nums == 0) ? (count / nums) : (count / nums + 1); List> data = new ArrayList>();...
  • 备注:将数据分页,以FixedThreadPool(定长线程池)+CountDownLatch(并发流程控制)+Callable(有返回值的多线程) + Future(接收Callable的返回值)的形式进行多线程处理数据。其中CountDownLatch的工作原理:在...
  • java 多线程处理mysql分页数据 在一般处理大量数据时,例如超过1W的数据。使用单线程处理效率较慢,这里就介绍一下我的处理思路。(如有问题,请指出。) 一. 定义线程池(这里使用的是定长线程池) final ...
  • 该项目使用多线程实现分页查询,分为两步,第一步查询list,第二步查询数量进行分页计算。 条数返回值类 @Data public class ThreadCountPage { private Integer sumCount; } 多线程实现Callable接口工具类 ...
  • 多线程查询

    千次阅读 2017-05-31 23:47:20
    今天遇到下载资金流水记录的场景。...下面示例展示了采用Callable和Future进行多线程查询并使用CountDownLatch进行多线程同步。// 进行首次查询(略),获取总页数 int totalPage; // 设置计数器,从0开始 final Coun
  • 多线程查询数据库

    2021-03-19 15:37:54
    原理是线程进行分页查询再将查询结果合并取出。 一、公共接口 public interface BaseService<T> { T template(); } 二、模板方法 public interface BaseThreadServiceTemplate<T> { // index为...
  • java多线程查询数据库

    2017-12-04 13:38:37
    java多线程并发查询数据库,使用线程池控制分页,并发查询
  • 调用分页接口使用多线程插入数据库 public Object insert() throws Exception { Map mapResult = restTemplate.getForObject("http://127.0.0.1:8088/msg", Map.class); //返回类型 // {"currentPage":1,...
  • java使用多线程查询大批量数据

    万次阅读 热门讨论 2019-12-11 18:18:22
    前言 在某些时候,一旦单表数据量过大,查询数据的时候就会变得...这个查询的过程,数据量一旦过大,单线程查询数据将会成为瓶颈,下面尝试使用多线程来尝试查询一张数据量较大的表 由于代码逻辑不是很难,直接上...
  • java使用多线程进行分页数据采集

    千次阅读 2017-03-25 11:04:53
    public void executeList(Date startDate, Date endDate,String subgamekind) { System.out.println("定时任务:抓取任务--->开始------->"+ sd1.format(new Date())); long start1 = System.currentTimeMillis();...
  • java 多线程--分页处理

    2019-05-08 18:01:24
    public void add() { ExecutorService executor = newFixedThreadPool(3); //?代表开启全部线程的数量 // 判断可是线程池可以结束 int pageSize = 10000; int pageIndex = 1; do { ...
  • Java多线程大批量同步数据(分页

    千次阅读 2019-09-27 11:33:52
    背景 最近遇到个功能,两个月有300w+的数据,之后还在累加,因一开始该数据就全部存储在mysql表,现需要展示在...一开始同步的时候,采用单线程,循环以分页的模式去同步这两张表数据,结果是…一晚上,只同步了30...
  • java多线程查询数据库(线程池) 需求介绍: 调用接口后一个页面要展示两个列表,而且数据量很大。 分析: 如果按原始方法进行两次查询再将结果返回当然也是可以的。但是查询时间就是两个查询的和,数据量很小的话...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,348
精华内容 29,339
关键字:

多线程分页查询