提交

pan

2025-12-04 db215dc033392d843cec846f0a8f9dbff2578c6a

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService_Outbound.cs

@@ -2,6 +2,7 @@
using Newtonsoft.Json;
using OfficeOpenXml.FormulaParsing.Excel.Functions.RefAndLookup;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
@@ -148,7 +149,29 @@
            List<Dt_LocationInfo>? locationInfos = null;

            CleanupPreviousInvalidLocks(outboundOrderDetails);
            // å¼€å¯äº‹åŠ¡ï¼Œä½¿ç”¨æ•°æ®åº“行级锁
            using (var transaction = _outboundOrderDetailService.Db.Ado.UseTran())
            {
                try
                {
                    // ä½¿ç”¨æ‚²è§‚锁锁定订单明细
                    var lockedOrderDetails = new List<Dt_OutboundOrderDetail>();
                    foreach (var key in keys)
                    {
                        var detail = _outboundOrderDetailService.Db.Ado.SqlQuerySingle<Dt_OutboundOrderDetail>(
                            "SELECT * FROM Dt_OutboundOrderDetail WITH (UPDLOCK, ROWLOCK) WHERE Id = @Id",
                            new { Id = key });

                        if (detail != null)
                        {
                            lockedOrderDetails.Add(detail);
                        }
                    }

                    if (!lockedOrderDetails.Any())
                    {
                        throw new Exception("未找到出库单明细信息");
                    }
            (List<Dt_StockInfo>, List<Dt_OutboundOrderDetail>, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result = _outboundOrderDetailService.AssignStockOutbound(outboundOrderDetails);
            if (result.Item1 != null && result.Item1.Count > 0)
            {
@@ -178,12 +201,21 @@
                orderDetails = result.Item2;
                outStockLockInfos = result.Item3;
                locationInfos = result.Item4;
                        transaction.CommitTran();
            }
            else
            {
                        transaction.RollbackTran();
                throw new Exception("无库存");
            }
                }
                catch (Exception)
                {
                    transaction.RollbackTran();
                    throw;
                }
            return (tasks, stockInfos, orderDetails, outStockLockInfos, locationInfos);
            }
        }
        /// <summary>
        /// æ¸…理之前的无效锁定记录
@@ -417,6 +449,65 @@
            return tasks;
        }

        #region å†…存锁管理器
        private static readonly ConcurrentDictionary<string, SemaphoreSlim> _normalmaterialLocks =
            new ConcurrentDictionary<string, SemaphoreSlim>();
        private static readonly ConcurrentDictionary<string, DateTime> _normallockLastUsed =
            new ConcurrentDictionary<string, DateTime>();
        private static readonly object _normalcleanupLock = new object();
        private static DateTime _normallastCleanupTime = DateTime.MinValue;

        /// <summary>
        /// èŽ·å–物料级内存锁
        /// </summary>
        private SemaphoreSlim GetNormalMaterialSemaphore(string materialCode, string batchNo, string supplyCode)
        {
            // åˆ›å»ºé”é”®ï¼šç‰©æ–™+批次+供应商
            string lockKey = $"MaterialLock_{materialCode}_{batchNo}_{supplyCode}";

            // æ¸…理长时间不用的锁（每小时清理一次）
            var now = DateTime.Now;
            if ((now - _normallastCleanupTime).TotalHours >= 1)
            {
                lock (_normalcleanupLock)
                {
                    if ((now - _normallastCleanupTime).TotalHours >= 1)
                    {
                        var keysToRemove = _normallockLastUsed
                            .Where(kvp => (now - kvp.Value).TotalHours > 2)
                            .Select(kvp => kvp.Key)
                            .ToList();

                        foreach (var key in keysToRemove)
                        {
                            if (_normalmaterialLocks.TryRemove(key, out var _semaphore))
                            {
                                _semaphore.Dispose();
                            }
                            _normallockLastUsed.TryRemove(key, out _);
                        }

                        _normallastCleanupTime = now;
                    }
                }
            }

            // èŽ·å–或创建信号量
            var semaphore = _normalmaterialLocks.GetOrAdd(lockKey, _ => new SemaphoreSlim(1, 1));
            _normallockLastUsed[lockKey] = now;

            return semaphore;
        }

        /// <summary>
        /// æ›´æ–°å†…存锁最后使用时间
        /// </summary>
        private void UpdateNormalMaterialLockUsedTime(string materialCode, string batchNo, string supplyCode)
        {
            string lockKey = $"MaterialLock_{materialCode}_{batchNo}_{supplyCode}";
            _normallockLastUsed[lockKey] = DateTime.Now;
        }
        #endregion
        /// <summary>
        /// ç”Ÿæˆå‡ºåº“任务
        /// </summary>
@@ -432,6 +523,51 @@
                List<Dt_OutboundOrderDetail> outboundOrderDetails = new List<Dt_OutboundOrderDetail>();
                List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
                List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
                // å…ˆèŽ·å–所有订单明细，确定需要锁定的物料
                var orderDetails = _outboundOrderDetailService.Repository.QueryData(x => keys.Contains(x.Id));
                if (orderDetails == null || orderDetails.Count == 0)
                {
                    return WebResponseContent.Instance.Error("未找到出库单明细信息");
                }

                // èŽ·å–所有需要锁定的物料分组
                var materialGroups = orderDetails
                    .GroupBy(x => new { x.MaterielCode, x.BatchNo, x.SupplyCode })
                    .Select(g => new
                    {
                        g.Key.MaterielCode,
                        g.Key.BatchNo,
                        g.Key.SupplyCode,
                        Count = g.Count()
                    })
                    .ToList();

                // æŒ‰é¡ºåºèŽ·å–所有物料的内存锁（按物料代码排序以避免死锁）
                var semaphores = new List<SemaphoreSlim>();
                var acquiredLocks = new List<(string MaterialCode, string BatchNo, string SupplyCode)>();

                try
                {
                    foreach (var group in materialGroups.OrderBy(g => g.MaterielCode).ThenBy(g => g.BatchNo))
                    {
                        var semaphore = GetMaterialSemaphore(group.MaterielCode, group.BatchNo, group.SupplyCode);

                        // ç­‰å¾…获取锁，最多等待30秒
                        bool lockAcquired = await semaphore.WaitAsync(TimeSpan.FromSeconds(30));

                        if (!lockAcquired)
                        {
                            // å¦‚果获取锁失败，释放已获取的所有锁
                            foreach (var acquiredSemaphore in semaphores)
                            {
                                acquiredSemaphore.Release();
                            }
                            return WebResponseContent.Instance.Error($"物料[{group.MaterielCode}]批次[{group.BatchNo}]分配繁忙，请稍后重试");
                        }

                        semaphores.Add(semaphore);
                        acquiredLocks.Add((group.MaterielCode, group.BatchNo, group.SupplyCode));
                    }

                (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_OutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) result = OutboundTaskDataHandle(keys, outStation);
                if (result.Item2 != null && result.Item2.Count > 0)
@@ -457,6 +593,20 @@

                WebResponseContent content = await GenerateOutboundTaskDataUpdateAsync(tasks, stockInfos, outboundOrderDetails, outStockLockInfos, locationInfos);
                return content;
                }
                finally
                {
                    // é‡Šæ”¾æ‰€æœ‰å†…存锁并更新使用时间
                    foreach (var semaphore in semaphores)
                    {
                        semaphore.Release();
                    }

                    foreach (var lockInfo in acquiredLocks)
                    {
                        UpdateMaterialLockUsedTime(lockInfo.MaterialCode, lockInfo.BatchNo, lockInfo.SupplyCode);
                    }
                }
            }
            catch (Exception ex)
            {
@@ -711,12 +861,88 @@


        #region åˆ†æ‰¹åˆ†é…åº“å­˜
        #region å†…存锁管理器
        private static readonly ConcurrentDictionary<string, SemaphoreSlim> _materialLocks =
            new ConcurrentDictionary<string, SemaphoreSlim>();
        private static readonly ConcurrentDictionary<string, DateTime> _lockLastUsed =
            new ConcurrentDictionary<string, DateTime>();
        private static readonly object _cleanupLock = new object();
        private static DateTime _lastCleanupTime = DateTime.MinValue;

        /// <summary>
        /// èŽ·å–物料级内存锁
        /// </summary>
        private SemaphoreSlim GetMaterialSemaphore(string materialCode, string batchNo, string supplyCode)
        {
            // åˆ›å»ºé”é”®ï¼šç‰©æ–™+批次+供应商
            string lockKey = $"MaterialLock_{materialCode}_{batchNo}_{supplyCode}";

            // æ¸…理长时间不用的锁（每小时清理一次）
            var now = DateTime.Now;
            if ((now - _lastCleanupTime).TotalHours >= 1)
            {
                lock (_cleanupLock)
                {
                    if ((now - _lastCleanupTime).TotalHours >= 1)
                    {
                        var keysToRemove = _lockLastUsed
                            .Where(kvp => (now - kvp.Value).TotalHours > 2)
                            .Select(kvp => kvp.Key)
                            .ToList();

                        foreach (var key in keysToRemove)
                        {
                            if (_materialLocks.TryRemove(key, out var _semaphore))
                            {
                                _semaphore.Dispose();
                            }
                            _lockLastUsed.TryRemove(key, out _);
                        }

                        _lastCleanupTime = now;
                    }
                }
            }

            // èŽ·å–或创建信号量
            var semaphore = _materialLocks.GetOrAdd(lockKey, _ => new SemaphoreSlim(1, 1));
            _lockLastUsed[lockKey] = now;

            return semaphore;
        }

        /// <summary>
        /// é‡Šæ”¾å†…存锁并更新最后使用时间
        /// </summary>
        private void UpdateMaterialLockUsedTime(string materialCode, string batchNo, string supplyCode)
        {
            string lockKey = $"MaterialLock_{materialCode}_{batchNo}_{supplyCode}";
            _lockLastUsed[lockKey] = DateTime.Now;
        }
        #endregion
        /// <summary>
        /// åˆ†æ‰¹åˆ†é…åº“å­˜
        /// </summary>
        public async Task<WebResponseContent> GenerateOutboundBatchTasksAsync(int orderDetailId, decimal batchQuantity, string outStation)
        {
            try
            {
                // å…ˆèŽ·å–订单明细信息，确定物料
                var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                    .FirstAsync(x => x.Id == orderDetailId);

                if (orderDetail == null)
                    return WebResponseContent.Instance.Error("未找到订单明细信息");

                // èŽ·å–物料级内存锁
                var semaphore = GetMaterialSemaphore(orderDetailId + orderDetail.MaterielCode, orderDetail.BatchNo, orderDetail.SupplyCode);

                // ç­‰å¾…获取内存锁，最多等待30秒
                bool memoryLockAcquired = await semaphore.WaitAsync(TimeSpan.FromSeconds(30));

                if (!memoryLockAcquired)
                    return WebResponseContent.Instance.Error("系统繁忙，请稍后重试");

            try
            {
                List<Dt_Task> tasks = new List<Dt_Task>();
@@ -751,6 +977,13 @@
                WebResponseContent content = await GenerateOutboundTaskDataUpdateAsync(tasks, stockInfos, outboundOrderDetails, outStockLockInfos, locationInfos);
                return content;
            }
                finally
                {
                    // é‡Šæ”¾å†…存锁
                    semaphore.Release();
                    UpdateMaterialLockUsedTime(orderDetail.MaterielCode, orderDetail.BatchNo, orderDetail.SupplyCode);
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
@@ -768,7 +1001,7 @@
            List<Dt_Task> tasks = new List<Dt_Task>();

            // èŽ·å–订单明细
            var outboundOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
            var outboundOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().With("UPDLOCK, ROWLOCK")
                .FirstAsync(x => x.Id == orderDetailId);

            if (outboundOrderDetail == null)