devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

mongodb批量删除数据效率问题_mongo大表删除数据慢

作者：正经夜光杯 | 2024-07-25 04:45:37

赞

踩

mongo大表删除数据慢

今天接到一个任务，线上的mongodb积累了大量的无用数据，导致宕机，现在对里面的数据进行批量删除。

其中库里面的一个log记录有2000w+条，他的存储字段比较少，格式如下：

{ "_id" : ObjectId("5ecb648b17bee8673ef09024"), "level" : 1, "pay" : 0, "rand" : 64090, "uid" : NumberLong(120196967) }

我们对这个表里面的删除记录就是将1年以上的数据进行清楚，根据ObjectId这个字段的生成规则，用如下的方法判断：

  1. Date date1 = new Date();
  2. System.out.println("开始统计要删除的时间 ：" + date1);
  3. DBCursor dbCursor = collection.find();
  4. int count = 0;
  5. while(dbCursor.hasNext()) {
  6.     DBObject object = dbCursor.next();
  7.     String id = object.get("_id").toString();
  8.     String time16Str = id.substring(0, 8);
  9.     long createTime = str16To10(time16Str);
  10.     if(createTime < lastTime) {
  11.         count++;
  12.     }
  13. }
  14. Date date2 = new Date();
  15. System.out.println("结束统计要删除的时间 ：" + date2);
  16. System.out.println("统计花费的时间 ：" + (date2.getTime()-date1.getTime()) + "ms");
  17. System.out.println("dbCursor count ：" + dbCursor.count());
  18. System.out.println("need del  count ：" + count);

统计运行的时间如下，从下图中可以看出2000+的统计时间大约1分钟不到，这个还是还是可以接收的：

  1. 开始统计要删除的时间 ：Tue May 26 18:38:07 CST 2020
  2. 结束统计要删除的时间 ：Tue May 26 18:38:50 CST 2020
  3. 统计花费的时间 ：43079ms
  4. dbCursor count ：21595385
  5. need del  count ：16398864

然后在if中添加删除的两行代码:

  1. if(createTime < lastTime) {            
  2.     DBObject query = new BasicDBObject().append("_id", new ObjectId(id));
  3.     WriteResult result = collection.remove(query);      //1
  4.     // collection.findAndModify(query, null, null, true, null, false, false); //2  
  5. }

上面两行代码的执行删除的时间截然不同，remove5分59s删除了36956，而findAndModify5分3s删除了127090，如果是要删除16398864条数据的话，remove大约需要44h,而findAndModify需要10h。

针对这种批量删除，设计的方案如下：

  1. public Long clearUserRecommandOldData() {
  2.     // 根据objectId清理两年之前的老数据
  3.     Calendar calendar = Calendar.getInstance();
  4.     calendar.add(Calendar.YEAR, -2);
  5.     final long lastTime = calendar.getTime().getTime();
  6.     final OpLogService service = this.opLogService;
  7.  
  8.     Long result = new MongoExecutor<Long>() {
  9.         @Override
  10.         protected Long doInMongo(MongoClient client) {
  11.             ExecutorService executorService = Executors.newFixedThreadPool(2);
  12.  
  13.             DB database = client.getDB(ConfigManager.get(GeoMongodbConfig.class).getServer().getDbName());
  14.             DBCollection collection = database.getCollection(COLLECTION_NAME);
  15.  
  16.             DBObject fields = new BasicDBObject();
  17.             fields.put("_id" , true);
  18.             // 游标每次从库里面一次拿出5w条数据，避免出现SocketTimeOut异常
  19.             DBCursor dbCursor = collection.find(new BasicDBObject(), fields).batchSize(CloverConstants.DBCUSTOR_BATCH_SIZE);
  20.             long count = 0;
  21.             List<Object> objectIds = new ArrayList<>();
  22.  
  23.             Date date1 = new Date();
  24.             logger.info("user_recommand开始统计， date:" + date1 + ", dbCursor count:" + dbCursor.count());
  25.  
  26.             while(dbCursor.hasNext()) {
  27.                 DBObject object = dbCursor.next();
  28.                 String id = object.get("_id").toString();
  29.                 String time16Str = id.substring(0, 8);  // 获取objectId中的16进制的创建时间
  30.                 long createTime = Long.valueOf(time16Str, 16) * 1000;
  31.                 if (createTime < lastTime) {
  32.                     count++;
  33.                     objectIds.add(object.get("_id"));
  34.  
  35.                     // 每次取出100条数据就另外开启一个线程来执行删除任务
  36.                     if(count % CloverConstants.DBCUSTOR_BATCH_SIZE == 0) {
  37.                         final List<Object> delObjectIds = new ArrayList<>(objectIds);
  38.                         objectIds.clear();
  39.                         threadPoolHandler(executorService, delObjectIds);
  40.                     }
  41.                 }
  42.             }
  43.             dbCursor.close();
  44.             Date date2 = new Date();
  45.             logger.info("user_recommand结束统计， date:" + date2 + ", cost time:" + (date2.getTime()-date1.getTime()) + "ms");
  46.             threadPoolHandler(executorService, objectIds);
  47.             return count;
  48.         }
  49.     }.execute();
  50.     if(result == null) {
  51.         result = 0l;
  52.     }
  53.     return result;
  54. }
  55.  
  56. private void threadPoolHandler(final ExecutorService executorService, final List<Object> objects) {
  57.     new MongoExecutor<Long>() {
  58.         @Override
  59.         protected Long doInMongo(MongoClient client) {
  60.             DB database = client.getDB(ConfigManager.get(GeoMongodbConfig.class).getServer().getDbName());
  61.             final DBCollection collection = database.getCollection(COLLECTION_NAME);
  62.             executorService.execute(new Runnable() {
  63.                 @Override
  64.                 public void run() {
  65.                     Date date1 = new Date();
  66.                     logger.info("user_recommand开始删除， date:" + date1 + ", count:" + objects.size());
  67.                     for(Object objectId : objects) {
  68.                         DBObject query = new BasicDBObject().append("_id", objectId);
  69.                         // 这个删除方法效率是remove的至少10倍
  70.                         collection.findAndModify(query, null, null, true, null, false, false);
  71.                     }
  72.                     Date date2 = new Date();
  73.                     logger.info("user_recommand结束删除， date:" + date2 + ", cost time:" + (date2.getTime()-date1.getTime()) + "ms");
  74.                 }
  75.             });
  76.             return 0l;
  77.         }
  78.     }.execute();
  79. }

这个方案的重要一点这这一行代码：

DBCursor dbCursor = collection.find(newBasicDBObject(), fields).batchSize(CloverConstants.DBCUSTOR_BATCH_SIZE);

find()中的两个参数，第一个表示查询条件，我这里是什么查询条件也没有，第二个表示查询返回的字段，这里一定要写，如果你只需要几个查询字段，一定要带上这个，上面的一条log记录它的json结构很小，如果你的json结构很大的话，每次查询返回一个很大的DBObject，会造成系统频繁的gc。

batchSize()中是这个数字我写的是100，表示游标每次从数据库一次拿100条数据到内存，这个值，不能设置的太大，也不要设置太小。

batchSize设置太大，会出现SocketTimeOut超时问题，设置太小，游标每次从数据库拿一条效率也很低。

现在的mongodb启动时设置的SocketTimeOut时间时5s，batchSize时100，这个也是测试设置了好几种才决定的。

代码里面还有一个很重要的点，就是下面这行：

// 每次取出100条数据就另外开启一个线程来执行删除任务
if(count % CloverConstants.DBCUSTOR_BATCH_SIZE == 0) {
final List<Object> delObjectIds = new ArrayList<>(objectIds);
objectIds.clear();
threadPoolHandler(executorService, delObjectIds);
}

每收集100条可删除的数据，然后就放到线程池里面去执行，线程池初始化设置了2个，

当前条件改成删除两年前的老数据，库里面一共时2100+的数据，删除数据有500+万条数据，耗时15min左右就删干净了，看了一下数据库里面增加的不是很频繁，在系统里面添加了一个定时器，每两个星期清理一次Mongodb中的数据。

补充：

上面这个方案弊端是一边遍历一边删除，dbCustor的游标一直在不停的变化，很可能在删除的时候会出现超时的异常，具体如下图：

上面这个就是某些数据删除过慢，在日志中打印出来的，之前用remove()做删除这个时间消耗的有2s-20s左右的都有。但是如果删除不是那么频繁的话就不会出现这个问题。

 

我们项目中需求是定时清理过期的数据，这张表现在有2100w+的记录，删除当前时间两年前的数据大约有500w+条，线上一个星期大约增长了10w+条数据，之前在本次测试23分钟大约删除了18w条，现在我做的删除具体代码如下：

  1. public Long clearUserRecommandOldData(final boolean auto) {
  2.     final TwoTuple<Long, Long> executeTime = opLogService.getExecuteTime(COLLECTION_NAME, auto);
  3.     // 判断当前的任务是否在可执行的指定时间片中
  4.     if (executeTime.getFirst() == 0l || executeTime.getSecond() == 0l) {
  5.         return 0l;
  6.     }
  7.     long now = System.currentTimeMillis();
  8.     if (now < executeTime.getFirst() || now > executeTime.getSecond()) {
  9.         return 0l;
  10.     }
  11.  
  12.     // 根据objectId清理两年之前的老数据
  13.     Calendar calendar = Calendar.getInstance();
  14.     calendar.add(Calendar.YEAR, -2);
  15.     final long twoYearsAgo = calendar.getTime().getTime();
  16.     final OpLogService service = this.opLogService;
  17.  
  18.     // 返回字段
  19.     DBObject fields = new BasicDBObject();
  20.     fields.put("_id", true);
  21.  
  22.     // 排序条件
  23.     DBObject orderBy = new BasicDBObject();
  24.     orderBy.put("_id", 1);  // 时间升序
  25.     long count = 0;
  26.     try {
  27.         MongoClient client = MongoManager.getInstance().getClient();
  28.         DB database = client.getDB(ConfigManager.get(GeoMongodbConfig.class).getServer().getDbName());
  29.         DBCollection collection = database.getCollection(COLLECTION_NAME);
  30.  
  31.         // 游标每次从库里面一次拿出100条数据，避免出现SocketTimeOut异常,
  32.         // 按_id升序排列，时间大于lastTime就立马返回，不用遍历所有
  33.         DBCursor dbCursor = collection.find(new BasicDBObject(), fields).sort(orderBy).batchSize(CloverConstants.DBCUSTOR_BATCH_SIZE);
  34.         Date date1 = new Date();
  35.         logger.error("user_recommand开始统计， date:" + date1 + ", dbCursor count:" + dbCursor.count());
  36.  
  37.         List<Object> objectIds = new ArrayList<>();
  38.         while (dbCursor.hasNext()) {
  39.             DBObject object = dbCursor.next();
  40.             String id = object.get("_id").toString();
  41.             String time16Str = id.substring(0, 8);  // 获取objectId中的16进制的创建时间
  42.             long createTime = Long.valueOf(time16Str, 16) * 1000;
  43.             if (createTime > twoYearsAgo)
  44.                 break;
  45.  
  46.             count++;
  47.             objectIds.add(object.get("_id"));
  48.  
  49.             // 每次取出100条数据就来执行删除任务
  50.             if (count % CloverConstants.DBCUSTOR_BATCH_SIZE == 0) {
  51.                 final List<Object> delObjectIds = new ArrayList<>(objectIds);
  52.                 objectIds.clear();
  53.                 // 避免删除频繁,让出一些空闲时间给主程序调用mongodb
  54.                 try {
  55.                     Thread.sleep(500);
  56.                 } catch (Exception e) {
  57.                     logger.error(COLLECTION_NAME + " clear sleep error" + e);
  58.                 }
  59.                 // 继续删除
  60.                 service.delOldData(collection, delObjectIds, COLLECTION_NAME, 0);
  61.             }
  62.  
  63.             // 如果划分的时间片用完，就结束执行，保证别的日志也能被清理到
  64.             if (System.currentTimeMillis() >= executeTime.getSecond()) {
  65.                 logger.error(COLLECTION_NAME + " time period over");
  66.                 break;
  67.             }
  68.         }
  69.         dbCursor.close();
  70.         Date date2 = new Date();
  71.         logger.error("user_recommand结束统计， date:" + date2 + ", cost time:" + (date2.getTime() - date1.getTime()) + "ms， del count:" + count);
  72.         service.delOldData(collection, objectIds, COLLECTION_NAME, 0);
  73.  
  74.         return count;
  75.     } catch (Exception e) {
  76.         logger.error(COLLECTION_NAME + "execute error:" + e.getMessage());
  77.         count += clearUserRecommandOldData(auto);
  78.     }
  79.     return count;
  80. }
  81.  
  82. public void delOldData(DBCollection collection, List<Object> objectIds, String colName, int startIndex) {
  83.     if (objectIds.isEmpty())
  84.         return;
  85.     if (startIndex >= objectIds.size())
  86.         return;
  87.  
  88.     //Date date1 = new Date();
  89.     //logger.info(colName + "开始删除， date:" + date1 + ", count:" + objectIds.size());
  90.  
  91.     try {
  92.         for (int i = startIndex; i < objectIds.size(); i++) {
  93.             DBObject query = new BasicDBObject().append("_id", objectIds.get(startIndex));
  94.             // 比remove删除效率高10+倍
  95.             collection.findAndModify(query, null, null, true, null, false, false);
  96.             startIndex++;
  97.             //collection.remove(query);
  98.         }
  99.     } catch (MongoException exception) {
  100.         logger.error("MongoException error, _id:" + objectIds.get(startIndex) + "error msg:" + exception.getMessage());
  101.         startIndex++;
  102.         delOldData(collection, objectIds, colName, startIndex);
  103.     }
  104.     //Date date2 = new Date();
  105.     //logger.info(colName + "结束删除， date:" + date2 + ", cost time:" + (date2.getTime() - date1.getTime()) + "ms");
  106.  
  107. }

具体删除策略如下：

线上的connections连接数配置的是5，所以采用的单线程删除策略；

开启一个定时器，每天3点-7点执行，每张表规定一个时间段删除，保证有限的时间内每张表都能够有时间删到；

保证你的时间段删除的数量比它每天的增长量要多，不然你怎么都删不完就尴尬了；

如果你的删除数据任务不是要求立马删完，可以删除一些数据之后，让线程休眠一段时间再继续删除，不然频繁删除不仅会一直占用着连接，线上写数据可能会有影响，而且会报SocketTimeOut异常；

  1. public TwoTuple<Long, Long> getExecuteTime(String colName, boolean auto) {
  2.         long startTime = 0l;
  3.         long endTime = 0l;
  4.         Calendar c = Calendar.getInstance();
  5.  
  6.         int nowHour = c.get(Calendar.HOUR_OF_DAY);
  7.         long now = c.getTimeInMillis();
  8.  
  9.         if (auto) {
  10.             // 定时器触发 3-7点之间，3-5执行user_recommend, 5-6执行op_log, 6-7执行op_result
  11.             int endHour = CloverConstants.CLEAR_END_HOUR;
  12.             if (colName.equals(FriendRecService.COLLECTION_NAME)) {
  13.                 endHour = 5;
  14.             } else if (colName.equals(COL_OP_LOG)) {
  15.                 endHour = 6;
  16.             }
  17.  
  18.             startTime = now;
  19.             c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), endHour, 0, 0);
  20.             endTime = c.getTimeInMillis();
  21.         } else {
  22.             // 手动触发,如果碰上定时器的执行时间段则不执行
  23.             startTime = now;
  24.  
  25.             long endTime1 = 0l;
  26.             if (nowHour < CloverConstants.CLEAR_START_HOUR) {
  27.                 c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), CloverConstants.CLEAR_START_HOUR, 0, 0);
  28.                 endTime1 = c.getTimeInMillis() - 5 * HeConsts.MILLISECONDS_PER_MINUTE;
  29.                 if (startTime > endTime1) {
  30.                     return Tuple.tuple(0l, 0l);
  31.                 }
  32.             } else if (nowHour >= CloverConstants.CLEAR_END_HOUR) {
  33.                 c.add(Calendar.DAY_OF_MONTH, 1);
  34.                 c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), CloverConstants.CLEAR_START_HOUR, 0, 0);
  35.                 endTime1 = c.getTimeInMillis() - 5 * HeConsts.MILLISECONDS_PER_MINUTE;
  36.             } else {
  37.                 return Tuple.tuple(0l, 0l);
  38.             }
  39.             // 手动触发，每个表删除时间分配2小时,保证手动执行每个表也有时间去删到
  40.             endTime = startTime + HeConsts.MILLISECONDS_PER_HOUR * 2;
  41.             //endTime = startTime + 5*60*1000;  // for test
  42.             if (endTime > endTime1) {
  43.                 endTime = endTime1;
  44.             }
  45.         }
  46.         return Tuple.tuple(startTime, endTime);
  47.     }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/878395
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号