提交

pan

2025-12-04 db215dc033392d843cec846f0a8f9dbff2578c6a

提交

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

@@ -5,6 +5,7 @@
using Org.BouncyCastle.Asn1.Ocsp;
using SqlSugar;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Net;
@@ -44,6 +45,12 @@
        private readonly IOutboundOrderService _outboundOrderService;
        private readonly IOutboundOrderDetailService _outboundOrderDetailService;
        private readonly IOutStockLockInfoService _outStockLockInfoService;

        // å­˜å‚¨èµ„源ID及其对应的锁对象。使用 ConcurrentDictionary ç¡®ä¿å¯¹å­—典操作本身的线程安全。
        private static readonly ConcurrentDictionary<string, object> _resourceLocks = new ConcurrentDictionary<string, object>();

        // å…¨å±€é™æ€é”ï¼šç”¨äºŽä¿æŠ¤ _resourceLocks å­—典中 GetOrAdd æˆ– TryRemove æ—¶çš„竞争
        private static readonly object _globalLocker = new object();
        public InvokeMESService(IHttpClientFactory httpClientFactory, ILogger<InvokeMESService> logger, IRepository<Dt_FeedbackToMes> feedbacktomesRepository, IRepository<Dt_StockInfoDetail> stockInfoDetailRepository, IRepository<Dt_StockInfo> stockInfoRepository, IRepository<Dt_InboundOrder> inboundOrderRepository, IOutboundOrderService outboundOrderService, IOutboundOrderDetailService outboundOrderDetailService, IOutStockLockInfoService outStockLockInfoService, IMaterialUnitService materialUnitService, IRepository<Dt_PickingRecord> pickingRecoreRepository)
        {
            _httpClientFactory = httpClientFactory;
@@ -225,6 +232,7 @@
        }

   

        /// <summary>
        /// 
        /// </summary>
@@ -232,6 +240,11 @@
        /// <param name="inout">入库传1  å‡ºåº“ä¼ 2</param>
        /// <returns></returns>
        public async Task<WebResponseContent> BatchOrderFeedbackToMes(List<string> orderNos, int inout)
        {
            // 1. ã€å†…存锁抢占】
            if (MemoryLockManager.TryAcquireLock(orderNos[0]))
            {
                try
        {
            if (inout == 1)
            {
@@ -368,6 +381,19 @@
                    }
                }

                    }
                }
                finally
                {
                    // 2. ã€é‡Šæ”¾å†…存锁】无论成功失败，必须释放
                    MemoryLockManager.ReleaseLock(orderNos[0]);
                }
            }
            else
            {
                // æŠ¢é”å¤±è´¥ï¼šè¯´æ˜Žæœ‰å¦ä¸€ä¸ªçº¿ç¨‹ï¼ˆWCS回调或人工操作）正在处理

                return WebResponseContent.Instance.OK("WMS正在处理此回传任务，请勿重复操作。");
            }
            return WebResponseContent.Instance.OK();
        }
@@ -810,4 +836,59 @@
            return $"{datePart}{counterPart:D3}";
        }
    }


    public static class MemoryLockManager
    {
        // å­˜å‚¨èµ„源ID及其对应的锁对象。使用 ConcurrentDictionary ç¡®ä¿å¯¹å­—典操作本身的线程安全。
        private static readonly ConcurrentDictionary<string, object> _resourceLocks = new ConcurrentDictionary<string, object>();

        // å…¨å±€é™æ€é”ï¼šç”¨äºŽä¿æŠ¤ _resourceLocks å­—典中 GetOrAdd æˆ– TryRemove æ—¶çš„竞争
        private static readonly object _globalLocker = new object();

        /// <summary>
        /// å°è¯•é”å®šä¸€ä¸ªèµ„源ID。
        /// </summary>
        /// <param name="resourceId">要锁定的资源ID（例如 InboundRecord ID）</param>
        /// <returns>是否成功获取锁</returns>
        public static bool TryAcquireLock(string resourceId)
        {
            object lockObject = null;

            // æ ¸å¿ƒæ€è·¯ï¼šä¸ºæ¯ä¸ªèµ„源创建一个唯一的锁对象
            lock (_globalLocker)
            {
                // å¦‚果资源ID不在字典中，则添加一个新的锁对象
                // å¦åˆ™ï¼Œä½¿ç”¨å·²å­˜åœ¨çš„锁对象
                lockObject = _resourceLocks.GetOrAdd(resourceId, new object());
            }

            // å°è¯•èŽ·å–资源特定的锁
            // ä½¿ç”¨ Monitor.TryEnter é¿å…é˜»å¡žï¼Œå¹¶å®žçŽ°éžé˜»å¡žçš„抢锁
            return Monitor.TryEnter(lockObject);
        }

        /// <summary>
        /// é‡Šæ”¾èµ„源ID的锁定。
        /// </summary>
        /// <param name="resourceId">要释放的资源ID</param>
        public static void ReleaseLock(string resourceId)
        {
            if (_resourceLocks.TryGetValue(resourceId, out object lockObject))
            {
                // ç¡®ä¿é‡Šæ”¾çš„是当前线程持有的锁
                if (Monitor.IsEntered(lockObject))
                {
                    Monitor.Exit(lockObject);

                    // é‡Šæ”¾é”åŽï¼Œå°è¯•ä»Žå­—典中移除这个锁对象，清理内存。
                    // å¿…须在 Monitor.Exit ä¹‹åŽæ‰§è¡Œã€‚
                    lock (_globalLocker)
                    {
                        _resourceLocks.TryRemove(resourceId, out _);
                    }
                }
            }
        }
    }
}

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

@@ -636,24 +636,25 @@
                if (userSelection == null) continue;

                // è®¡ç®—该托盘实际可用数量
                var availableQuantity = CalculateAvailableQuantity(stock, outboundOrderDetail.MaterielCode,
                    outboundOrderDetail.BatchNo, outboundOrderDetail.SupplyCode);
                var availableQuantity = CalculateAvailableQuantityByBarcode(stock, outboundOrderDetail.MaterielCode,
           outboundOrderDetail.BatchNo, outboundOrderDetail.SupplyCode, userSelection.Barcode);

                // ç¡®å®šåˆ†é…æ•°é‡ï¼šå–用户选择数量、可用数量和剩余需求的最小值
                var assignQuantity = Math.Min(Math.Min(userSelection.UseableQuantity, availableQuantity),remainingNeedQuantity);

                if (assignQuantity <= 0) continue;

                // æ‰§è¡Œåˆ†é…
                var (actualAssigned, barcode) = AssignStockQuantity(stock, outboundOrderDetail, assignQuantity);
                // æ‰§è¡Œåˆ†é…ï¼Œä½¿ç”¨ç”¨æˆ·é€‰æ‹©çš„条码
                var actualAssigned = AssignStockQuantity(stock, outboundOrderDetail, assignQuantity, userSelection.Barcode);

                if (actualAssigned > 0)
                {
                    outStocks.Add(stock);
                    totalAssignedFromUserSelection += actualAssigned;
                    remainingNeedQuantity -= actualAssigned;

                    // åˆ›å»ºé”å®šè®°å½•
                    var lockInfo = CreateOutStockLockInfo(outboundOrder, outboundOrderDetail, stock, actualAssigned, barcode);
                    // åˆ›å»ºé”å®šè®°å½•ï¼Œä½¿ç”¨ç”¨æˆ·é€‰æ‹©çš„条码
                    var lockInfo = CreateOutStockLockInfo(outboundOrder, outboundOrderDetail, stock, actualAssigned, userSelection.Barcode);
                    outStockLockInfos.Add(lockInfo);
                }
            }
@@ -721,7 +722,25 @@

            return (outStocks, outboundOrderDetail, outStockLockInfos, locationInfos);
        }
        private decimal CalculateAvailableQuantityByBarcode(Dt_StockInfo stock, string materielCode, string batchNo, string supplyCode, string barcode)
        {
            var query = stock.Details.AsQueryable()
                .Where(d => d.MaterielCode == materielCode &&
                           (d.StockQuantity - d.OutboundQuantity) > 0 &&
                           d.Barcode == barcode);

            if (!string.IsNullOrEmpty(batchNo))
            {
                query = query.Where(x => x.BatchNo == batchNo);
            }

            if (!string.IsNullOrEmpty(supplyCode))
            {
                query = query.Where(d => d.SupplyCode == supplyCode);
            }

            return query.Sum(d => d.StockQuantity - d.OutboundQuantity);
        }
        // è¾…助方法
        private decimal CalculateAvailableQuantity(Dt_StockInfo stock, string materielCode, string batchNo, string supplyCode)
        {
@@ -732,6 +751,41 @@
                .ToList();

            return relevantDetails.Sum(d => d.StockQuantity - d.OutboundQuantity);
        }

        private decimal AssignStockQuantity(Dt_StockInfo stock, Dt_OutboundOrderDetail detail, decimal assignQuantity, string barcode)
        {
            decimal remainingAssign = assignQuantity;

            // æŒ‰å…ˆè¿›å…ˆå‡ºåˆ†é…æŒ‡å®šæ¡ç çš„库存明细
            var query = stock.Details.AsQueryable()
                .Where(d => d.MaterielCode == detail.MaterielCode &&
                           (d.StockQuantity - d.OutboundQuantity) > 0 &&
                           d.Barcode == barcode); // åªåˆ†é…æŒ‡å®šæ¡ç 

            if (!string.IsNullOrEmpty(detail.BatchNo))
            {
                query = query.Where(x => x.BatchNo == detail.BatchNo);
            }
            // å¦‚果出库单有供应商要求，按供应商过滤
            if (!string.IsNullOrEmpty(detail.SupplyCode))
            {
                query = query.Where(d => d.SupplyCode == detail.SupplyCode);
            }
            var sortedDetails = query.ToList().OrderBy(d => d.CreateDate);

            foreach (var stockDetail in sortedDetails)
            {
                if (remainingAssign <= 0) break;

                var available = stockDetail.StockQuantity - stockDetail.OutboundQuantity;
                var assign = Math.Min(available, remainingAssign);

                stockDetail.OutboundQuantity += assign;
                remainingAssign -= assign;
            }

            return assignQuantity - remainingAssign; // è¿”回实际分配数量
        }

        private (decimal assignedQuantity, string barcode) AssignStockQuantity(Dt_StockInfo stock, Dt_OutboundOrderDetail detail, decimal assignQuantity)
@@ -843,8 +897,8 @@
                    return (false, $"托盘[{selection.PalletCode}]不存在");
                }

                var available = CalculateAvailableQuantity(stock, outboundOrderDetail.MaterielCode,
                    outboundOrderDetail.BatchNo, outboundOrderDetail.SupplyCode);
                var available = CalculateAvailableQuantityByBarcode(stock, outboundOrderDetail.MaterielCode,
                    outboundOrderDetail.BatchNo, outboundOrderDetail.SupplyCode,selection.Barcode);

                if (available <= 0)
                {

 ÏîÄ¿´úÂë/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)