.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。

如何使用代码

备注

尽量通过合理的设计规避离线悲观锁，应用场景不会有很多，有使用过的朋友，请留下您宝贵的意见。