.NET：防止並發修改 之 離線悲觀鎖代碼示例（離線悲觀鎖）

背景

系統會出現並發，上篇文章我介紹了如何使用“離線樂觀鎖”保證並發，離線樂觀鎖適合處理那些重新編輯成本不大的單據，如果某個單據用戶花了10分鍾進行編輯，提交時你告訴他出現並發了，他心里肯定會罵娘的，今天介紹的“離線悲觀鎖”就可以避免這種情況。

思路

小明簽出了源代碼，小強就不能簽出了，我們目前的源代碼系統就是用的這種悲觀策略。

實現

核心代碼

離線悲觀鎖管理器接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Happy.Application.PessimisticLock
{
    /// <summary>
    /// 離線悲觀鎖管理器接口。
    /// </summary>
    public interface ILockManager
    {
        /// <summary>
        /// 獲取鎖。
        /// </summary>
        /// <param name="entity">鎖的主體，如：表名或聚合名。</param>
        /// <param name="key">鎖的主體的唯一標識，如：主鍵或唯一索引。</param>
        /// <param name="owner">鎖的擁有者，如：UserId或SessionId。</param>
        /// <returns>獲取鎖成功就返回true，否則返回false。</returns>
        bool AcquireLock(string entity, string key, string owner);

        /// <summary>
        /// 釋放鎖。
        /// </summary>
        /// <param name="entity">鎖的主體，如：表名或聚合名。</param>
        /// <param name="key">鎖的主體的唯一標識，如：主鍵或唯一索引。</param>
        /// <param name="owner">鎖的擁有者，如：UserId或SessionId。</param>
        void ReleaseLock(string entity, string key, string owner);


        /// <summary>
        /// 釋擁有者的所有鎖。
        /// </summary>
        /// <param name="owner">鎖的擁有者，如：UserId或SessionId。</param>
        void ReleaseLocks(string owner);
    }
}

基於內存的離線悲觀鎖管理器

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Happy.DesignByContract;
using Happy.Application.PessimisticLock.Internal;

namespace Happy.Application.PessimisticLock
{
    /// <summary>
    /// 基於內存的離線悲觀鎖管理器。
    /// </summary>
    public sealed class MemoryLockManager : ILockManager
    {
        private static readonly Dictionary<string, MemoryLockItem> _items = new Dictionary<string, MemoryLockItem>();

        /// <inheritdoc />
        public bool AcquireLock(string entity, string key, string owner)
        {
            entity.MustNotNullAndNotWhiteSpace("entity");
            key.MustNotNullAndNotWhiteSpace("key");
            owner.MustNotNullAndNotWhiteSpace("owner");

            var item = MemoryLockItem.Crete(entity, key, owner);

            lock (_items)
            {
                if (!IsLocked(item.Identifier))
                {
                    SetLockItem(item);

                    return true;
                }

                return IsLockedBy(item);
            }
        }

        /// <inheritdoc />
        public void ReleaseLock(string entity, string key, string owner)
        {
            entity.MustNotNullAndNotWhiteSpace("entity");
            key.MustNotNullAndNotWhiteSpace("key");
            owner.MustNotNullAndNotWhiteSpace("owner");

            var item = MemoryLockItem.Crete(entity, key, owner);

            lock (_items)
            {
                if (!IsLockedBy(item))
                {
                    throw new InvalidOperationException(string.Format(Messages.Error_CanNotReleaseLock, owner));
                }

                RemoveLockItem(item);
            }
        }

        /// <inheritdoc />
        public void ReleaseLocks(string owner)
        {
            lock (_items)
            {
                foreach (var keypair in _items)
                {
                    if (keypair.Value.Owner == owner)
                    {
                        RemoveLockItem(keypair.Value);
                    }
                }
            }
        }

        private static bool IsLocked(string identifier)
        {
            return _items.ContainsKey(identifier);
        }

        private static void SetLockItem(MemoryLockItem item)
        {
            _items[item.Identifier] = item;
        }

        private static bool IsLockedBy(MemoryLockItem item)
        {
            if (!IsLocked(item.Identifier))
            {
                return false;
            }

            return _items[item.Identifier].Owner == item.Owner;
        }

        private static void RemoveLockItem(MemoryLockItem item)
        {
            _items.Remove(item.Identifier);
        }
    }
}

離線悲觀鎖代理

/**
 * 離線悲觀鎖代理。
 * 
 * @static
 * @class PessimisticLockProxy
 * @namespace Happy.server
 */
Ext.define('Happy.server.PessimisticLockProxy', {
    alternateClassName: ['PessimisticLockProxy'],
    singleton: true,
    requires: ['Happy.Ajax'],

    acquireLock: function (entity, key, success, failure) {
        var me = this;

        Happy.Ajax.callAction({
            url: '/LockManager/AcquireLock',
            params: { entity: entity, key: key },
            success: success,
            failure: failure
        });
    },

    releaseLock: function (entity, key, success, failure) {
        var me = this;

        Happy.Ajax.callAction({
            url: '/LockManager/ReleaseLock',
            params: { entity: entity, key: key },
            success: success,
            failure: failure
        });
    }
});

運行效果

 

代碼下載

地址：http://happy.codeplex.com/SourceControl/latest。因為項目正在重構中，請下載最新源代碼，不要下載Happy-1.0.0.3。

如何使用代碼

備注

盡量通過合理的設計規避離線悲觀鎖，應用場景不會有很多，有使用過的朋友，請留下您寶貴的意見。