循环中读取数据库、嵌套循环引起的性能问题

最新推荐文章于 2025-03-21 14:26:32 发布
最新推荐文章于 2025-03-21 14:26:32 发布
阅读量1.2w 收藏 6
点赞数 1
分类专栏： K/3 Cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fyq891014/article/details/51260235
版权
背景说明

K/3 Cloud的代码开发规范，严格禁止在循环中到数据库读取数据，这会引发严重的性能问题：
需在循环外，一次性取回需要的数据。

但对于提前取回的数据，如果没有预先处理，常常需要嵌套一个循环到集合中取数，这也是非常严重的性能问题。

本帖将通过一个案例，编写三套实现方法，演示循环取数，典型的错误方案与推荐方案。




案例说明

需求：
生成销售出库单时，自动检查库存，从有存货的仓库出库。


实现方案：
编写单据转换插件，物料、数量携带完毕后，到数据库取有存货的仓库，填写到仓库字段中；
如果某一个仓库的存货不够，则拆行。
此方案需要逐个（循环）读取物料的库存，随后基于库存实现拣货，有非常大的性能隐患。

特别说明：
此案例，主要用来演示如何合理规避循环取数，与嵌套循环，解决性能问题；
很多业务细节，被略过。
实际实现代码，要比本案例复杂的多，千万不能直接照搬此案例代码，解决实际问题




典型代码解析

这个案例的完整插件代码比较长，我们先略过与本帖主题无关的外围代码，以及拣货逻辑，聚焦在可能发生性能问题的循环代码中。
如下，直接介绍循环的三种实现方式：

错误方案一：循环中读取数据

20160331 00循环取数1.png 

说明：
在循环中，读取每行物料的即时库存：会引发严重的性能问题，加重数据库压力


错误方案二：嵌套循环取数

20160331 00循环取数2.png 

20160331 00循环取数3.png 

说明：
这里嵌套了一个循环搜索符合本物料的库存，循环总次数可能非常惊人
如单据体有1,000行，实际循环次数将超过1,000,000次
如单据体有2,000行，实际循环次数将超过4,000,000次
总循环次数，成指数上升。而且，单据体行数越多，性能压力越明显，甚至有可能1个小时都动不了。

推荐方案：

20160331 00循环取数4.png 

20160331 00循环取数5.png 

说明：
本函数最终循环的次数（1000行单据体）：
1,000行即时库存 + 1,000行单据体 = 2,000次
循环次数是成倍数增长，跟方案二的指数增长相比，循环次数完全不在一个数量级。
性能表现也是可控的。




完整的插件代码


附：完整的插件代码，包含了错误方案、推荐方案三个版本的实现方法

拣货实现算法，未实际验证，且实现非常简单，仅供参考，请勿照搬为实际应用


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using Kingdee.BOS;
using Kingdee.BOS.Util;
using Kingdee.BOS.Core;
using Kingdee.BOS.Core.Metadata;
using Kingdee.BOS.Core.Metadata.ConvertElement;
using Kingdee.BOS.Core.Metadata.ConvertElement.PlugIn;
using Kingdee.BOS.Core.Metadata.ConvertElement.PlugIn.Args;
using Kingdee.BOS.Core.Metadata.EntityElement;
using Kingdee.BOS.Core.Metadata.FieldElement;
using Kingdee.BOS.Orm;
using Kingdee.BOS.Orm.DataEntity;
using Kingdee.BOS.App;
using Kingdee.BOS.App.Data;
using Kingdee.BOS.Contracts;
namespace JDSample.ServicePlugIn.BillConvert
{
    public class S160330StockPickingConvPlug : AbstractConvertPlugIn
    {
        /// <summary>
        /// 单据体元数据
        /// </summary>
        private Entity _entity = null;
        /// <summary>
        /// 物料字段元数据
        /// </summary>
        private BaseDataField _fldMaterial = null;
        
        /// <summary>
        /// 仓库字段元数据
        /// </summary>
        private BaseDataField _fldStock = null;
        /// <summary>
        /// 基本单位数量字段元数据
        /// </summary>
        private BaseQtyField _fldBaseQty = null;
        /// <summary>
        /// 字段携带完毕，且关联关系已经顺利构建
        /// </summary>
        /// <param name="e"></param>
        public override void OnAfterCreateLink(CreateLinkEventArgs e)
        {
            // 获取后面要用到的元素的元数据
            this._entity = e.TargetBusinessInfo.GetEntity("FEntity");
            this._fldMaterial = e.TargetBusinessInfo.GetField("FMaterialID") as BaseDataField;
            this._fldStock = e.TargetBusinessInfo.GetField("FStockID") as BaseDataField;
            this._fldBaseQty = e.TargetBusinessInfo.GetField("FBaseUnitQty") as BaseQtyField;
            // 读取已经生成的销售出库单：随后要对销售出库单，按单循环进行拣货与拆单据体行
            ExtendedDataEntity[] billObjExts = e.TargetExtendedDataEntities.FindByEntityKey("FBillHead");
            List<DynamicObject> billObjs = new List<DynamicObject>();
            foreach (var billObjExt in billObjExts)
            {
                // 开始拣货
                //this.FunVersion1(billObjExt.DataEntity);            // 第一种实现代码：性能非常糟糕
                //this.FunVersion2(billObjExt.DataEntity);            // 第二种实现代码：性能同样糟糕
                this.FunVersion3(billObjExt.DataEntity);            // 第三种实现代码：推荐版本
                billObjs.Add(billObjExt.DataEntity);
            }
            // 重新展开单据中包含的单据体行
            // 特别说明：如果去掉此语句，新拆分的行，不会执行表单服务策略
            e.TargetExtendedDataEntities.Parse(billObjs, e.TargetBusinessInfo);
        }
        /// <summary>
        /// 实现函数一：
        /// 在循环中读取数据库，
        /// 错误代码典型样本
        /// </summary>
        /// <param name="billObj">生成的下游单据集合</param>
        private void FunVersion1(DynamicObject billObj)
        {
            DynamicObjectCollection rows = this._entity.DynamicProperty.GetValue(billObj)
                as DynamicObjectCollection;
            // 对单据体进行循环：逐行实现拣货
            // 需从后往前循环，新拆分的行，避开循环
            int rowCount = rows.Count;
            for (int i = rowCount - 1; i >= 0; i--)
            {
                DynamicObject currRow = rows[ i ];      // 当前行
                // 取当前行物料：当前行没有填写物料，或者没有填写基本单位数量，不需要拣货，略过
                DynamicObject materialObj = this._fldMaterial.DynamicProperty.GetValue(currRow) as DynamicObject;
                if (materialObj == null) continue;
                // 物料的MasterId：即时库存，使用的是物料的MasterId
                long materialMasterId = Convert.ToInt64(materialObj[FormConst.MASTER_ID]);
                // 性能问题点：在循环中执行SQL，读取数据：
                // 读取有库存的仓库，按数量排序(未考虑货主、保管者、批号等其他库存维度，实际解决方案不能照搬)
                string sql = "SELECT FSTOCKID, FQTY from T_STK_INVENTORY WHERE FMATERIALID = @FMATERIALID ORDER BY FQTY DESC";
                SqlParam param = new SqlParam("@FMATERIALID", KDDbType.Int64, materialMasterId);
                var stockQtyList = DBUtils.ExecuteDynamicObject(this.Context, sql, null, null, System.Data.CommandType.Text, param);
                if (stockQtyList.Count == 0)
                {// 没有找到有库存的仓库，不需要拣货，略过此行
                    continue;   
                }
                else 
                {// 找到多个仓库有库存，需要灵活拣货
                    var newRows = this.DoStockPicking(rows, currRow, stockQtyList.ToList());
                }
            }
        }
        /// <summary>
        /// 实现函数二：
        /// 把循环读取数据库，放在循环外一次性读取；
        /// 但在循环中嵌套了循环，性能同样糟糕；
        /// </summary>
        /// <param name="billObj">生成的下游单据集合</param>
        private void FunVersion2(DynamicObject billObj)
        {
            DynamicObjectCollection rows = this._entity.DynamicProperty.GetValue(billObj)
                as DynamicObjectCollection;
            // 优化后算法：
            // 先获取所有的物料，然后统一到即时库存中读取这些物料的库存量，
            // 一次性取数,避免在循环中读取数据库
            HashSet<long> materialMasterIds = new HashSet<long>();
            // 循环取得所有的物料
            foreach (var currRow in rows)
            {
                // 取当前行物料：当前行没有填写物料，或者没有填写基本单位数量，不需要拣货，略过
                DynamicObject materialObj = this._fldMaterial.DynamicProperty.GetValue(currRow) as DynamicObject;
                if (materialObj == null) continue;
                // 物料的MasterId：即时库存，使用的是物料的MasterId
                long materialMasterId = Convert.ToInt64(materialObj[FormConst.MASTER_ID]);
                if (materialMasterIds.Contains(materialMasterId) == false)
                {
                    materialMasterIds.Add(materialMasterId);
                }
            }
            // 一次性读取所有物料的库存
            string sql = @"
SELECT T1.FMATERIALID, T1.FSTOCKID, T1.FQTY 
  FROM T_STK_INVENTORY T1 
INNER JOIN (table(fn_StrSplit(@FMATERIALID,',',1))) T2 
    ON (T1.FMATERIALID = T2.FID) 
ORDER BY T1.FMATERIALID, T1.FQTY DESC";
            SqlParam param = new SqlParam("@FMATERIALID", KDDbType.udt_inttable, materialMasterIds.ToArray());
            var allStockQtyList = DBUtils.ExecuteDynamicObject(this.Context, sql, null, null, System.Data.CommandType.Text, param);
            // 对单据体进行循环：逐行实现拣货
            // 需从后往前循环，新拆分的行，避开循环
            int rowCount = rows.Count;
            for (int i = rowCount - 1; i >= 0; i--)
            {
                DynamicObject currRow = rows[ i ];      // 当前行
                // 取当前行物料：当前行没有填写物料，或者没有填写基本单位数量，不需要拣货，略过
                DynamicObject materialObj = this._fldMaterial.DynamicProperty.GetValue(currRow) as DynamicObject;
                if (materialObj == null) continue;
                // 物料的MasterId：即时库存，使用的是物料的MasterId
                long materialMasterId = Convert.ToInt64(materialObj[FormConst.MASTER_ID]);
                // 搜索此物料的库存数据 : 物料 = 当前行的物料
                // 性能点：在循环中，从一个集合中搜索与当前行匹配的数据，使循环次数成指数上升
                var stockQtyList = (from p in allStockQtyList 
                                    where ( Convert.ToInt64(p["FMaterialId"]) == materialMasterId)
                                    select p).ToList();
                if (stockQtyList.Count == 0)
                {// 没有找到有库存的仓库，不需要拣货，略过此行
                    continue;
                }
                else
                {// 找到多个仓库有库存，需要灵活拣货
                    var newRows = this.DoStockPicking(rows, currRow, stockQtyList.ToList());
                }
            }
        }
        /// <summary>
        /// 实现函数三：
        /// 充分考虑了性能问题：
        /// 1. 避免在循环中读取数据；
        /// 2. 预先建立数据字典，避免在循环中嵌套循环
        /// 推荐的实现方案
        /// </summary>
        /// <param name="billObj">生成的下游单据集合</param>
        private void FunVersion3(DynamicObject billObj)
        {
            DynamicObjectCollection rows = this._entity.DynamicProperty.GetValue(billObj)
                as DynamicObjectCollection;
            // 优化后算法：
            // 先获取所有的物料，然后统一到即时库存中读取这些物料的库存量，
            // 一次性取数,避免在循环中读取数据库
            HashSet<long> materialMasterIds = new HashSet<long>();
            // 循环取得所有的物料
            foreach (var currRow in rows)
            {
                // 取当前行物料：当前行没有填写物料，或者没有填写基本单位数量，不需要拣货，略过
                DynamicObject materialObj = this._fldMaterial.DynamicProperty.GetValue(currRow) as DynamicObject;
                if (materialObj == null) continue;
                // 物料的MasterId：即时库存，使用的是物料的MasterId
                long materialMasterId = Convert.ToInt64(materialObj[FormConst.MASTER_ID]);
                if (materialMasterIds.Contains(materialMasterId) == false)
                {
                    materialMasterIds.Add(materialMasterId);
                }
            }
            // 一次性读取所有物料的库存
            string sql = @"
SELECT T1.FMATERIALID, T1.FSTOCKID, T1.FQTY 
  FROM T_STK_INVENTORY T1 
INNER JOIN (table(fn_StrSplit(@FMATERIALID,',',1))) T2 
    ON (T1.FMATERIALID = T2.FID) 
ORDER BY T1.FMATERIALID, T1.FQTY DESC";
            SqlParam param = new SqlParam("@FMATERIALID", KDDbType.udt_inttable, materialMasterIds.ToArray());
            var allStockQtyList = DBUtils.ExecuteDynamicObject(this.Context, sql, null, null, System.Data.CommandType.Text, param);
            // 优化后算法：
            // 对已经取得的物料库存数据，按物料进行分组，以便后面在循环中，快速取到本物料的库存
            Dictionary<long, List<DynamicObject>> dctStockQty = new Dictionary<long, List<DynamicObject>>();
            foreach (var stockQty in allStockQtyList)
            {
                long materialMasterId = Convert.ToInt64(stockQty["FMaterialId"]);
                if (dctStockQty.ContainsKey(materialMasterId) == false)
                {
                    dctStockQty.Add(materialMasterId, new List<DynamicObject>());
                }
                dctStockQty[materialMasterId].Add(stockQty);
            }
            // 对单据体进行循环：逐行实现拣货
            // 需从后往前循环，新拆分的行，避开循环
            int rowCount = rows.Count;
            for (int i = rowCount - 1; i >= 0; i--)
            {
                DynamicObject currRow = rows[ i ];      // 当前行
                // 取当前行物料：当前行没有填写物料，或者没有填写基本单位数量，不需要拣货，略过
                DynamicObject materialObj = this._fldMaterial.DynamicProperty.GetValue(currRow) as DynamicObject;
                if (materialObj == null) continue;
                // 物料的MasterId：即时库存，使用的是物料的MasterId
                long materialMasterId = Convert.ToInt64(materialObj[FormConst.MASTER_ID]);
                // 搜索此物料的库存数据 : 物料 = 当前行的物料
                // 性能点：在循环中，从一个集合中搜索与当前行匹配的数据，使循环次数成指数上升
                List<DynamicObject> stockQtyList = null;
                if (dctStockQty.TryGetValue(materialMasterId, out stockQtyList) == false
                    || stockQtyList.Count == 0)
                {// 没有找到有库存的仓库，不需要拣货，略过此行
                    continue;
                }
                else
                {// 找到多个仓库有库存，需要灵活拣货
                    var newRows = this.DoStockPicking(rows, currRow, stockQtyList.ToList());
                }
            }
        }
        /// <summary>
        /// 拣货的实现逻辑：只是简单的实现拣货逻辑，仅供参考
        /// </summary>
        /// <param name="rows">单据体行集合</param>
        /// <param name="currRow">当前行</param>
        /// <param name="stockQtyList">物料即时库存数据</param>
        /// <returns>新拆分出来的行</returns>
        private List<DynamicObject> DoStockPicking(
            DynamicObjectCollection rows,
            DynamicObject currRow,
            List<DynamicObject> stockQtyList)
        {
            List<DynamicObject> newRows = new List<DynamicObject>();
            // 取本次需出库的基本单位数量
            decimal baseQty = Convert.ToDecimal(this._fldBaseQty.DynamicProperty.GetValue(currRow));
            if (baseQty == 0)
            {
                return newRows;     // 无数量，不需要拣货，略过
            }
            // 读取单据数据的服务对象：提前准备好，后续需要不断使用
            IViewService viewService = ServiceHelper.GetService<IViewService>();
            // 首先判断第一个仓库库存是否足够：如够，直接使用此仓库出库
            decimal stockQty = Convert.ToDecimal(stockQtyList[0]["FQty"]);
            if (stockQtyList.Count == 1 || stockQty > baseQty)
            {
                long stockId = Convert.ToInt64(stockQtyList[0]["FStockId"]);
                // 给仓库字段赋值
                DynamicObject[] stockObjs = viewService.LoadFromCache(
                    this.Context, new object[] { stockId }, this._fldStock.RefFormDynamicObjectType);
                this._fldStock.RefIDDynamicProperty.SetValue(currRow, stockId);
                this._fldStock.DynamicProperty.SetValue(currRow, stockObjs[0]);
            }
            else
            {// 需要使用多个仓库出库
                // 首先把第一个仓库，填写到当前行，其他仓库，拆分新行出库
                long stockId = Convert.ToInt64(stockQtyList[0]["FStockId"]);
                // 给仓库字段赋值：取仓库数据，是使用了缓存的，性能比较好
                DynamicObject[] stockObjs = viewService.LoadFromCache(
                    this.Context, new object[] { stockId }, this._fldStock.RefFormDynamicObjectType);
                this._fldStock.RefIDDynamicProperty.SetValue(currRow, stockId);
                this._fldStock.DynamicProperty.SetValue(currRow, stockObjs[0]);
                // 调整此仓库出库数量
                this._fldBaseQty.DynamicProperty.SetValue(currRow, stockQty);
                baseQty = baseQty - stockQty;
                // 剩余数量从其他仓库出库
                int stockIndex = 1;     // 当前仓库指针
                while (baseQty > 0 && stockIndex < stockObjs.Length)
                {
                    // 拆分出新行出库
                    DynamicObject newRow = (DynamicObject)currRow.Clone(false, true);
                    // 把新行，插入到单据中，排在当前行之后
                    rows.Insert(rows.IndexOf(currRow) + stockIndex, newRow);
                    // 填写仓库、数量
                    long otherStockId = Convert.ToInt64(stockQtyList[stockIndex]["FStockId"]);
                    decimal otherStockQty = Convert.ToDecimal(stockQtyList[stockIndex]["FQty"]);
                    if (stockIndex == stockObjs.Length - 1)
                    {
                        // 最后一个仓库，全部剩余数量，从此仓库出库
                        otherStockQty = baseQty;
                    }
                    if (otherStockQty > 0)
                    {
                        // 给仓库字段赋值
                        DynamicObject[] otherStockObjs = viewService.LoadFromCache(
                            this.Context, new object[] { otherStockId }, this._fldStock.RefFormDynamicObjectType);
                        this._fldStock.RefIDDynamicProperty.SetValue(newRow, otherStockId);
                        this._fldStock.DynamicProperty.SetValue(newRow, otherStockObjs[0]);
                        // 调整此仓库出库数量
                        this._fldBaseQty.DynamicProperty.SetValue(newRow, otherStockQty);
                        baseQty = baseQty - otherStockQty;
                    }
                    stockIndex++;  // 仓库指针向后偏移：使用下一个仓库出库
                }
            }
            return newRows;
        }
    }
}


2023-06-25 mysql-嵌套循环优化-块嵌套循环算法-分析
悟世之路
06-25 555
mysql对于连接的处理最基本的就是嵌套循环, 有几个表就对着做几层循环.这种做法导致整体的时间复杂度达到了U*R*S, 对于朴素的嵌套循环的算法, 优化的目标就是减少整体的嵌套循环的次数.一种做法是条件变换, 将条件尽可能的以降低循环次数的目标做修剪。另一种做法是使用中间结果, 加快整体的循环处理。本文分析块嵌套循环算法就是使用中间结果的做法。需要注意BNL在mysql8.0.20中被hash join算法取代。
java 解决多次嵌套循环查询数据库导致代码中数据处理慢的问题
小姐姐
03-28 5993
业务现象：代码中有一部分代码多次嵌套循环和数据处理，执行速度很慢 解决方案：通过多线程 1：启用多线程 private final static Executor executor = Executors.newFixedThreadPool(3); 2、初始化设置count，即等待(await)count个线程或一个线程count次计数，通过工作线程来countDown计数减一，直到计数为0，await阻塞结束；目的：保证所有线程都走完 final CountDownLatch latch =.
避免在循环中调用数据库操作：提升C#程序性能的有效方法
学习之路，创业之光
08-02 771
其实最佳实践是用像SqlSugar这样的ORM类来搞。在开发C#应用程序时，特别是在处理大量数据时，不可避免地需要与数据库进行交互。然而，如果在循环中频繁进行数据库操作，会导致性能问题、增加数据库负担，甚至可能导致瓶颈。本文将探讨如何避免在循环中进行数据库操作，并提供详细的例子来说明这些方法。 为什么要避免在循环中调用数据库操作？ 在循环中进行数据库操作会带来以下几个问题： 性能问题：每一次数据库操作都会涉及网络通信、IO操作和数据库处理时间，频繁调用会大幅降低程序的性能。 增加数据库负担：频繁的数据
实战 - 不要在for循环中调用数据库
你今天真好看呀
06-14 8686
循环调用数据库会导致性能很差，所以千万不要循环调用数据库，对循环调用数据库的改进方法，就是把数据全部查出来，然后组装或者批量查询。存在的问题：for循环中存在批量查询数据库的情况，需要批量查询数据库处理掉 2. 第一次改进后 存在的问题：可以不要在for循环中组装map，而是放在for循环外组装好，在for循环中调用 3. 第二次改进后 4. 测试根据部门层级路径获取获取部门id接口 比如根据 “部门/研发部/SIR” 获取SIR的部门id........................
Java开发中循环查询数据库优化实战指南
最新发布
qq_17404201的博客
03-21 420
循环查询优化是一个常见问题，没有一种方案适合所有场景。数据量大小 📊业务需求 🎯系统资源 💻来选择合适的优化方案。记住：过度优化可能带来新的问题，要在性能和可维护性之间找到平衡点！加油！💪。
for循环中操作数据库
莫失莫忘
03-21 1万+
业务中出现在循环中频繁查询数据库对比数据，频繁连接数据库耗费资源。 可以将数据取出放进list进行操作 可以利用sql中in 或者 exists 进行批量查询，减少连接次数 List<A> listA = dao.getAlist(); Map<String,Object> mapA = new HashMap<String,Object>(); //将a...
java for循环访问数据库_java 线程循环读取数据库
weixin_31528001的博客
02-27 1686
我之前有一个做法就写一个定时器。20秒中执行一次。然后去判断线程池的数量。如果线程池空闲就继续去读数据库。如果线程池中的线程没处理完。就继续处理。等下一个20秒再去判断。/*** 截至时间20150922*/private int totalPages = 6778;// 每20秒执行一次@Scheduled(cron="*/20 * * * * ?")public void myTest() {...
循环里使用数据库操作
qdexception专栏
11-18 402
RT,应尽量避免。 如有需要，查询后存入集合类，遍历集合类做完逻辑判断，进行批量update操作以及后续查询。
Jmeter 循环读取数据库中所有数据，并传递请求
songlh1234的博客
09-05 3769
一、Jmeter连接数据库，首先需要下载数据库连接驱动。我用的数据库是MySQL，如果有用其他数据库的，需要下载对应驱动。驱动的版本不低于数据库的版本，否则可能连接报错。 MySQL数据驱动mysql jdbc驱动包下载地址https://dev.mysql.com/downloads/connector/j/ 下载完成后，将jar包放到jmeter目录中D:\JMeter\apach...
递归循环读取省市区json文件数据，并保存到数据库中（很全面）
11-20
本示例中的“递归循环读取省市区json文件数据，并保存到数据库中”是一个全面的教程，它涵盖了从JSON解析到数据库交互的关键技术。以下是这个过程涉及的主要知识点： 1. **JSON (JavaScript Object Notation)**：...
Thinkphp的volist标签嵌套循环使用教程
10-25
本教程将详细讲解如何在ThinkPHP中使用`<volist>`标签进行嵌套循环。 首先，`<volist>`标签的基本语法如下： ```html 数组名" id="变量名"> <!-- 循环体 --> ``` 在这里，`name`属性指定了需要遍历的数组或集合...
for循环里面连接mysql,通过访问数据库使用For循环
weixin_28858229的博客
01-25 503
Hello everyoneAm using a For Loop to access records from my database but the code opens instead of a specific record base on values passed by the user. These values a fields in the database which i w...
如果由于大量数据插入数据库导致数据库性能持续下降问题，该如何进行性能优化呢？
这个夏天,晚上一起散步吧,可以的话,带上你的猫
02-06 2071
数据库性能优化、mysql、插入优化
不要在循环中访问数据库，这样会严重影响数据库性能
热门推荐
qq_43693520的博客
02-13 1万+
不要在循环中访问数据库，这样会严重影响数据库性能 先说一个可能会在循环中查询数据库的应用场景： 购物网站，有两个基本表，一个表存储商品的基本信息，比如商品价格，商品描述…，一个表存储商品的图片url， ...
循环查询数据库的性能问题及优化
05-27 1万+
问题背景：在for循环中，不断访问数据库查询数据。代码如下：优化前数据库查询语句：private static String selectSql = "select * from captain.resourceAccessSetting where backupProId = ?";优化前代码：for (RecordInfo recordInfo : recordInfos) { ...
for循环以及数据库查询优化方案
weixin_58216062的博客
01-18 3222
三、结语本文主要优化方式，都是结合多线程进行优化并推崇用iava8的对应写法。具体iava8语法不了解的可以自行寻找资料进行学习如果数据量少的情况下用foreach的循环写法Stream流循环针对数据量大的情况下会更具优势，小数据不明显。
Java不要在循环中访问数据库，这样会严重影响数据库性能
heng_yan的博客
08-15 9409
参考url：https://blog.youkuaiyun.com/qq_43693520/article/details/87122323
在循环里创建数据库连接，严重影响数据库性能
Harakin的博客
10-14 4234
  在循环里面去操作数据库肯定会慢的，而且还容易碰到新手，在循环里面创建数据库连接，会导致连接数满。一般查询的话，在外层一次性查询出来 然后 在逻辑层去循环组织数据。如果是新增，则可以考虑使用批量插入的方法去处理。 查询的话，在外层一次性查询出来 然后 在逻辑层去循环组织数据。不要循环查询数据库，（尤其是递归查询组织树）经过测试两者在相同数据（258条数据）的情况下性能相差6倍。 如果是更新（...
循环读取到数据库
Liquor2的博客
09-02 680
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值