C#编程之c#自定义业务锁-职坐标

C#编程之c#自定义业务锁

小标 2018-10-22 来源：阅读 954 评论 0

摘要：本文主要向大家介绍了C#编程之c#自定义业务锁，通过具体的内容向大家展示，希望对大家学习C#编程有所帮助。

本文主要向大家介绍了C#编程之c#自定义业务锁，通过具体的内容向大家展示，希望对大家学习C#编程有所帮助。

我们有这样的使用场景，某个订单在修改信息的时候，其他人不能修改相关的信息，比如不能做支付，不能退单等等，那么我们可以根据单号进行加锁，多Monitor做了如下扩展
定义接口

//// 文件名称：ILockExt.cs
//// 创建日期：2018-06-07 10:44:39
// 功能描述：自定义锁接口
//
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.ConstrainedExecution;
using System.Text;

namespace Km.Utils.Helpers
{
///

    /// 功能描述:自定义锁接口
    ////// 创建日期:2018-06-07 10:41:47
    //////

    public interface ILockExt : IDisposable
    {
        ///

        /// 功能描述:在指定对象上获取排他锁。
        ////// 创建日期:2018-06-07 10:25:29
        //////

///

在其上获取监视器锁的对象
void Enter(object obj);

///

        /// 功能描述:获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
        ////// 创建日期:2018-06-07 10:27:21
        //////

///

要在其上等待的对象
///

尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为true
void Enter(object obj, ref bool lockTaken);

///

        /// 功能描述:释放指定对象上的排他锁
        ////// 创建日期:2018-06-07 10:36:51
        //////

///

在其上释放锁的对象
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        void Exit(object obj);

        ///

        /// 功能描述:通知等待队列中的线程锁定对象状态的更改。
        ////// 创建日期:2018-06-07 10:37:15
        //////

///

线程正在等待的对象
void Pulse(object obj);

///

        /// 功能描述:通知所有的等待线程对象状态的更改。
        ////// 创建日期:2018-06-07 10:37:40
        //////

///

发送脉冲的对象
void PulseAll(object obj);

///

        /// 功能描述:尝试获取指定对象的排他锁
        ////// 创建日期:2018-06-07 10:37:55
        //////

///

在其上获取锁的对象。
///

如果当前线程获取该锁，则为 true；否则为 false。

bool TryEnter(object obj);

///

        /// 功能描述:在指定的毫秒数内尝试获取指定对象上的排他锁。
        ////// 创建日期:2018-06-07 10:38:11
        //////

///

在其上获取锁的对象
///

等待锁所需的毫秒数
///

如果当前线程获取该锁，则为 true；否则为 false。

bool TryEnter(object obj, int millisecondsTimeout);

///

        /// 功能描述:在指定的毫秒数内尝试获取指定对象上的排他锁。
        ////// 创建日期:2018-06-07 10:38:34
        //////

///

obj
///

lockTaken
void TryEnter(object obj, ref bool lockTaken);

///

        /// 功能描述:在指定的时间量内尝试获取指定对象上的排他锁。
        ////// 创建日期:2018-06-07 10:39:28
        //////

///

在其上获取锁的对象
///

System.TimeSpan，表示等待锁所需的时间量。值为 -1 毫秒表示指定无限期等待。
///

如果当前线程在不阻止的情况下获取该锁，则为 true；否则为 false

bool TryEnter(object obj, TimeSpan timeout);

///

        /// 功能描述:在指定的毫秒数中，尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁
        ////// 创建日期:2018-06-07 10:40:54
        //////

///

在其上获取锁的对象
///

等待锁所需的毫秒数
///

尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。
void TryEnter(object obj, int millisecondsTimeout, ref bool lockTaken);

///

        /// 功能描述:在指定的一段时间内，尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
        ////// 创建日期:2018-06-07 11:12:21
        //////

///

在其上获取锁的对象
///

用于等待锁的时间。值为 -1 毫秒表示指定无限期等待
///

尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。
void TryEnter(object obj, TimeSpan timeout, ref bool lockTaken);

///

        /// 功能描述:释放对象上的锁并阻止当前线程，直到它重新获取该锁。
        ////// 创建日期:2018-06-07 11:12:45
        //////

///

要在其上等待的对象
///

如果调用由于调用方重新获取了指定对象的锁而返回，则为 true。如果未重新获取该锁，则此方法不会返回。

bool Wait(object obj);

///

        /// 功能描述:释放对象上的锁并阻止当前线程，直到它重新获取该锁。如果指定的超时间隔已过，则线程进入就绪队列。
        ////// 创建日期:2018-06-07 11:13:13
        //////

///

要在其上等待的对象
///

线程进入就绪队列之前等待的毫秒数
///

如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。

bool Wait(object obj, int millisecondsTimeout);

///

        /// 功能描述:释放对象上的锁并阻止当前线程，直到它重新获取该锁。如果指定的超时间隔已过，则线程进入就绪队列。
        ////// 创建日期:2018-06-07 11:13:35
        //////

///

要在其上等待的对象
///

System.TimeSpan，表示线程进入就绪队列之前等待的时间量。
///

如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。

bool Wait(object obj, TimeSpan timeout);

///

        /// 功能描述:释放对象上的锁并阻止当前线程，直到它重新获取该锁。如果指定的超时间隔已过，则线程进入就绪队列。此方法还指定是否在等待之前退出上下文的同步域（如果处于同步上下文中的话）然后重新获取该同步域。
        ////// 创建日期:2018-06-07 11:14:02
        //////

///

要在其上等待的对象
///

线程进入就绪队列之前等待的毫秒数
///

如果在等待前退出并重新获取上下文的同步域（如果在同步上下文中），则为 true；否则为 false。
///

如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。

bool Wait(object obj, int millisecondsTimeout, bool exitContext);

///

        /// 功能描述:释放对象上的锁并阻止当前线程，直到它重新获取该锁。如果指定的超时间隔已过，则线程进入就绪队列。可以在等待之前退出同步上下文的同步域，随后重新获取该域。
        ////// 创建日期:2018-06-07 11:14:34
        //////

///

要在其上等待的对象
///

System.TimeSpan，表示线程进入就绪队列之前等待的时间量
///

如果在等待前退出并重新获取上下文的同步域（如果在同步上下文中），则为 true；否则为 false。
///

如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。

bool Wait(object obj, TimeSpan timeout, bool exitContext);

///

        /// 功能描述:在指定对象上获取排他锁
        ////// 创建日期:2018-06-07 10:09:25
        //////

///

在其上获取监视器锁的对象
///

ILockExt对象

ILockExt EnterLock(object obj);
///

        /// 功能描述:获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
        ////// 创建日期:2018-06-07 10:10:02
        //////

///

要在其上等待的对象
///

尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。Note如果没有发生异常，则此方法的输出始终为true
///

ILockExt对象

ILockExt EnterLock(object obj, ref bool lockTaken);
///

        /// 功能描述:尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
        ////// 创建日期:2018-06-07 10:17:29
        //////

///

在其上获取锁的对象
///

尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。
///

返回值

ILockExt TryEnterLock(object obj, ref bool lockTaken);
///

        /// 功能描述:在指定的毫秒数内尝试获取指定对象上的排他锁。
        ////// 创建日期:2018-06-07 10:14:36
        //////

///

在其上获取锁的对象
///

等待锁所需的毫秒数
///

如果当前线程获取该锁，则为 true；否则为 false
///

ILockExt对象

ILockExt TryEnterLock(object obj, int millisecondsTimeout, ref bool lockTaken);
///

        /// 功能描述:在指定的时间量内尝试获取指定对象上的排他锁。
        ////// 创建日期:2018-06-07 10:15:50
        //////

///

在其上获取锁的对象
///

System.TimeSpan，表示等待锁所需的时间量。值为 -1 毫秒表示指定无限期等待。
///

如果当前线程获取该锁，则为 true；否则为 false
///

ILockExt对象

        ILockExt TryEnterLock(object obj, TimeSpan timeout, ref bool lockTaken);
    }
}

View Code
定义基类

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

namespace Km.Utils.Helpers
{
    ///

    /// 功能描述:自定义锁
    ////// 创建日期:2018-06-07 10:49:26
    //////

    public class LockExt : ILockExt
    {
        private static Dictionary

m_lstLocks = new Dictionary();
///

/// 获取一个新实例
///

        public static ILockExt Instance
        {
            get
            {
                return new LockExt();
            }
        }
        ///

/// 字符串锁类型格式化 by beck.huang 2018-06-07 11:00:25
///

        public string LockFormate
        {
            get;
            set;
        }
        //锁对象
        private int objLockKey;

        #region 构造函数
        ///

        /// 功能描述:构造函数
        ////// 创建日期:2018-06-07 10:49:46
        //////

        public LockExt()
        {

        }
        ~LockExt()
        {
            Dispose();
        }
        ///

        /// 功能描述:执行与释放或重置非托管资源相关的应用程序定义的任务。
        ////// 创建日期:2018-06-07 10:49:18
        //////

        public void Dispose()
        {
            if (objLockKey != 0 && m_lstLocks.ContainsKey(objLockKey))
            {
                Monitor.Pulse(m_lstLocks[objLockKey]);
                Monitor.Exit(m_lstLocks[objLockKey]);
                lock (m_lstLocks)
                {
                    //如果可以尝试获得锁，则表示没有其他地方使用锁，则移除锁
                    if (Monitor.TryEnter(m_lstLocks[objLockKey], 0))
                    {
                        Monitor.Exit(m_lstLocks[objLockKey]);
                        m_lstLocks.Remove(objLockKey);
                    }
                }
            }
        }
        #endregion

        ///

        /// 功能描述:设置锁
        ////// 创建日期:2018-06-07 11:59:44
        //////

        /// obj
        private void SetLockObj(object obj)
        {
            if (obj is string)
            {
                if (string.IsNullOrEmpty(LockFormate) || LockFormate.IndexOf("{0}") < 0)
                {
                    LockFormate = "{0}";
                }
                objLockKey = string.Format(LockFormate, obj).GetHashCode();
            }
            else
            {
                objLockKey = obj.GetHashCode();
            }
        }

        ///

        /// 功能描述:在指定对象上获取排他锁。
        ////// 创建日期:2018-06-07 10:25:29
        //////

        /// 在其上获取监视器锁的对象
        public void Enter(object obj)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    m_lstLocks.Add(objLockKey, Guid.NewGuid().ToString());
                }
            }
            Monitor.Enter(m_lstLocks[objLockKey]);
        }

        ///

        /// 功能描述:获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
        ////// 创建日期:2018-06-07 10:27:21
        //////

        /// 要在其上等待的对象
        /// 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为true
        public void Enter(object obj, ref bool lockTaken)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    m_lstLocks.Add(objLockKey, Guid.NewGuid().ToString());
                }
            }
            Monitor.Enter(m_lstLocks[objLockKey], ref lockTaken);
        }

        ///

        /// 功能描述:释放指定对象上的排他锁
        ////// 创建日期:2018-06-07 10:36:51
        //////

        /// 在其上释放锁的对象
        public void Exit(object obj)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    return;
                }
            }
            Monitor.Exit(m_lstLocks[objLockKey]);
        }

        ///

        /// 功能描述:通知等待队列中的线程锁定对象状态的更改。
        ////// 创建日期:2018-06-07 10:37:15
        //////

        /// 线程正在等待的对象
        public void Pulse(object obj)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    return;
                }
            }
            Monitor.Pulse(m_lstLocks[objLockKey]);
        }

        ///

        /// 功能描述:通知所有的等待线程对象状态的更改。
        ////// 创建日期:2018-06-07 10:37:40
        //////

        /// 发送脉冲的对象
        public void PulseAll(object obj)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    return;
                }
            }
            Monitor.PulseAll(m_lstLocks[objLockKey]);
        }

        ///

        /// 功能描述:尝试获取指定对象的排他锁
        ////// 创建日期:2018-06-07 10:37:55
        //////

        /// 在其上获取锁的对象。
        /// 如果当前线程获取该锁，则为 true；否则为 false。
        public bool TryEnter(object obj)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    m_lstLocks.Add(objLockKey, Guid.NewGuid().ToString());
                }
            }
            bool bln = Monitor.TryEnter(m_lstLocks[objLockKey]);
            if (!bln)
            {
                lock (m_lstLocks)
                {
                    m_lstLocks.Remove(objLockKey);
                }
            }
            return bln;
        }

        ///

        /// 功能描述:在指定的毫秒数内尝试获取指定对象上的排他锁。
        ////// 创建日期:2018-06-07 10:38:11
        //////

        /// 在其上获取锁的对象
        /// 等待锁所需的毫秒数
        /// 如果当前线程获取该锁，则为 true；否则为 false。
        public bool TryEnter(object obj, int millisecondsTimeout)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    m_lstLocks.Add(objLockKey, Guid.NewGuid().ToString());
                }
            }
            bool bln = Monitor.TryEnter(m_lstLocks[objLockKey], millisecondsTimeout);
            if (!bln)
            {
                lock (m_lstLocks)
                {
                    m_lstLocks.Remove(objLockKey);
                }
            }
            return bln;
        }

        ///

        /// 功能描述:在指定的毫秒数内尝试获取指定对象上的排他锁。
        ////// 创建日期:2018-06-07 10:38:34
        //////

        /// obj
        /// lockTaken
        public void TryEnter(object obj, ref bool lockTaken)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    m_lstLocks.Add(objLockKey, Guid.NewGuid().ToString());
                }
            }
            Monitor.TryEnter(m_lstLocks[objLockKey], ref  lockTaken);
            if (!lockTaken)
            {
                if (!lockTaken)
                {
                    lock (m_lstLocks)
                    {
                        m_lstLocks.Remove(objLockKey);
                    }
                }
            }
        }

        ///

        /// 功能描述:在指定的时间量内尝试获取指定对象上的排他锁。
        ////// 创建日期:2018-06-07 10:39:28
        //////

        /// 在其上获取锁的对象
        /// System.TimeSpan，表示等待锁所需的时间量。值为 -1 毫秒表示指定无限期等待。
        /// 如果当前线程在不阻止的情况下获取该锁，则为 true；否则为 false
        public bool TryEnter(object obj, TimeSpan timeout)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    m_lstLocks.Add(objLockKey, Guid.NewGuid().ToString());
                }
            }
            bool lockTaken = Monitor.TryEnter(m_lstLocks[objLockKey], timeout);
            if (!lockTaken)
            {
                lock (m_lstLocks)
                {
                    m_lstLocks.Remove(objLockKey);
                }
            }
            return lockTaken;
        }

        ///

        /// 在其上获取锁的对象
        /// 等待锁所需的毫秒数
        /// 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。
        public void TryEnter(object obj, int millisecondsTimeout, ref bool lockTaken)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    m_lstLocks.Add(objLockKey, Guid.NewGuid().ToString());
                }
            }
            Monitor.TryEnter(m_lstLocks[objLockKey], millisecondsTimeout, ref  lockTaken);
            if (!lockTaken)
            {
                lock (m_lstLocks)
                {
                    m_lstLocks.Remove(objLockKey);
                }
            }
        }

        ///

        /// 在其上获取锁的对象
        /// 用于等待锁的时间。值为 -1 毫秒表示指定无限期等待
        /// 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。
        public void TryEnter(object obj, TimeSpan timeout, ref bool lockTaken)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    m_lstLocks.Add(objLockKey, Guid.NewGuid().ToString());
                }
            }
            Monitor.TryEnter(m_lstLocks[objLockKey], timeout, ref  lockTaken);
            if (!lockTaken)
            {
                lock (m_lstLocks)
                {
                    m_lstLocks.Remove(objLockKey);
                }
            }
        }

        ///

        /// 功能描述:释放对象上的锁并阻止当前线程，直到它重新获取该锁。
        ////// 创建日期:2018-06-07 11:12:45
        //////

        /// 要在其上等待的对象
        ///  如果调用由于调用方重新获取了指定对象的锁而返回，则为 true。如果未重新获取该锁，则此方法不会返回。
        public bool Wait(object obj)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    return false;
                }
            }
            return Monitor.Wait(m_lstLocks[objLockKey]);
        }

        ///

        /// 要在其上等待的对象
        /// 线程进入就绪队列之前等待的毫秒数
        /// 如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。
        public bool Wait(object obj, int millisecondsTimeout)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    return false;
                }
            }
            return Monitor.Wait(m_lstLocks[objLockKey], millisecondsTimeout);
        }

        ///

        /// 要在其上等待的对象
        /// System.TimeSpan，表示线程进入就绪队列之前等待的时间量。
        /// 如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。
        public bool Wait(object obj, TimeSpan timeout)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    return false;
                }
            }
            return Monitor.Wait(m_lstLocks[objLockKey], timeout);
        }

        ///

        /// 要在其上等待的对象
        /// 线程进入就绪队列之前等待的毫秒数
        ///  如果在等待前退出并重新获取上下文的同步域（如果在同步上下文中），则为 true；否则为 false。
        /// 如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。
        public bool Wait(object obj, int millisecondsTimeout, bool exitContext)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    return false;
                }
            }
            return Monitor.Wait(m_lstLocks[objLockKey], millisecondsTimeout, exitContext);
        }

        ///

        /// 要在其上等待的对象
        /// System.TimeSpan，表示线程进入就绪队列之前等待的时间量
        ///  如果在等待前退出并重新获取上下文的同步域（如果在同步上下文中），则为 true；否则为 false。
        /// 如果在指定的时间过期之前重新获取该锁，则为 true；如果在指定的时间过期之后重新获取该锁，则为 false。此方法只有在重新获取该锁后才会返回。
        public bool Wait(object obj, TimeSpan timeout, bool exitContext)
        {
            SetLockObj(obj);
            lock (m_lstLocks)
            {
                if (!m_lstLocks.ContainsKey(objLockKey))
                {
                    return false;
                }
            }
            return Monitor.Wait(m_lstLocks[objLockKey], timeout, exitContext);
        }

        ///

        /// 功能描述:在指定对象上获取排他锁
        ////// 创建日期:2018-06-07 10:09:25
        //////

        /// 在其上获取监视器锁的对象
        /// ILockExt对象
        public ILockExt EnterLock(object obj)
        {
            Enter(obj);
            return this;
        }
        ///

        /// 功能描述:获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
        ////// 创建日期:2018-06-07 10:10:02
        //////

        /// 要在其上等待的对象
        /// 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。Note如果没有发生异常，则此方法的输出始终为true
        /// ILockExt对象
        public ILockExt EnterLock(object obj, ref bool lockTaken)
        {
            Enter(obj, ref lockTaken);
            return this;
        }
        ///

        /// 功能描述:尝试获取指定对象上的排他锁，并自动设置一个值，指示是否获取了该锁。
        ////// 创建日期:2018-06-07 10:17:29
        //////

        /// 在其上获取锁的对象
        /// 尝试获取锁的结果，通过引用传递。输入必须为 false。如果已获取锁，则输出为 true；否则输出为 false。即使在尝试获取锁的过程中发生异常，也会设置输出。
        /// 返回值
        public ILockExt TryEnterLock(object obj, ref bool lockTaken)
        {
            TryEnter(obj, ref lockTaken);
            return this;
        }
        ///

        /// 功能描述:在指定的毫秒数内尝试获取指定对象上的排他锁。
        ////// 创建日期:2018-06-07 10:14:36
        //////

        /// 在其上获取锁的对象
        /// 等待锁所需的毫秒数
        /// 如果当前线程获取该锁，则为 true；否则为 false
        /// ILockExt对象
        public ILockExt TryEnterLock(object obj, int millisecondsTimeout, ref bool lockTaken)
        {
            TryEnter(obj, millisecondsTimeout, ref lockTaken);
            return this;
        }
        ///

        /// 功能描述:在指定的时间量内尝试获取指定对象上的排他锁。
        ////// 创建日期:2018-06-07 10:15:50
        //////

        /// 在其上获取锁的对象
        ///  System.TimeSpan，表示等待锁所需的时间量。值为 -1 毫秒表示指定无限期等待。
        /// 如果当前线程获取该锁，则为 true；否则为 false
        /// ILockExt对象
        public ILockExt TryEnterLock(object obj, TimeSpan timeout, ref bool lockTaken)
        {
            TryEnter(obj, timeout, ref lockTaken);
            return this;
        }
    }
}

View Code
定义业务锁

//// 文件名称：LockExtList.cs
//// 创建日期：2018-06-07 11:46:47
// 功能描述：锁列表
//
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Km.Utils.Helpers
{
    /* 说明
     * 注：
     * 编写锁步骤说明：
     * 1、编写对应类继承LockExt
     * 2、编写属性如下
     *   public static ILockExt Instance
        {
            get
            {
                LockOfTable l = new LockOfTable();
                l.LockFormate = "BillTableLock({0})";
                return l;
            }
        }
     *
     * 使用锁说明：
     * 1、快捷使用如下
     *      //排队获得锁
     *      using (LockOfTable.Instance.EnterLock("台位号"))
     *      {
     *          //你的操作
     *      }
     *      //尝试获得锁
     *      bool blnLockTaken = false;
     *      using (LockOfTable.Instance.TryEnterLock("台位号", ref blnLockTaken))
     *      {
     *          if (!blnLockTaken)
     *          {
     *              //台位已被锁定
     *              return;
     *          }
     *          //你的操作
     *      }
     *
     * 2、普通使用如下（更多的控制，但是要手动调用Exit进行释放锁）
     *      LockOfTable tableLock = LockOfTable.Instance;
     *      tableLock.Enter("台位号");
     *      tableLock.Pulse("台位号");
     *      tableLock.Wait("台位号");
     *      tableLock.Exit("台位号");
     *      ...
     */

    #region 台位锁
    ///

    /// 功能描述:台位锁
    ////// 创建日期:2018-06-07 11:30:45
    //////

    public class LockOfTable : LockExt
    {
        public static ILockExt Instance
        {
            get
            {
                LockOfTable l = new LockOfTable();
                l.LockFormate = "BillTableLock({0})";
                return l;
            }
        }
    }
    #endregion

    #region 出品单锁
    ///

    /// 功能描述:出品单锁
    ////// 创建日期:2018-06-07 11:35:56
    //////

    public class LockOfBill0 : LockExt
    {
        public static ILockExt Instance
        {
            get
            {
                LockOfTable l = new LockOfTable();
                l.LockFormate = "Bill0Lock({0})";
                return l;
            }
        }
    }
    #endregion
}

View Code
使用

using (LockOfTable.Instance.EnterLock("123456"))
            {
                Console.WriteLine("enter:" + i);
                Console.WriteLine(i);
                Thread.Sleep(1000);
            }

View Code

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标编程语言C#.NET频道！

visualstudio c#图解教程 c#编程进阶

本文由 @小标发布于职坐标。未经许可，禁止转载。