lock(this)实际上是个坑

　　这里不考虑分布式或者多台负载均衡的状况只考虑单台机器,多台服务器可使用分布式锁。出于线程安全的缘由，不少种场景你们可能看代码中看到lock的出现，尤为是在资金类的处理环节。 可是lock(this)真的达到你的需求了吗？下面用实例来讲明

　　理论常识很少说，回到业务场景，举个例子咱们的需求通常就是在某个订单进入某个安全优先级比较高的流程时要针对这笔订单作到线程互斥。至于缘由，这里再插一个概念，大部分orm在作更新操做时，实际上作的是全参数更新，所谓全参数更新，假如一个订单表上有10个字段，咱们只须要更新其中的一个金额字段，可是在传统orm框架中实际上在订单的实体类中赋值了全部字段而在更新操做中这些字段所有参与了更新，因此在高并发的场景下，若是有2个线程针对同一个订单操做，而且没有额外的保护程序（例如数据库锁、版本号等）那么在这种传统框架下后一个线程更新可能就会覆盖掉前一个线程的操做。所以lock的手段能够当作是一道保护墙。 那么接下来咱们经过实例看一下lock4种不一样方式(并不是4种类别)之间的区别

　　代码很简单 在结果截图后直接附上

　　 1. Lock(this)

　　能够看出lock(this),若是this是个普通的类非静态非单例，那么lock（this）并不知足咱们的需求,甚至除了当前线程并看不出有任何做用。

　　2. Lock(LockString)

Lock(LockString) 从结果上来看比较契合要求，对于同一笔订单作到的线程互斥，对于不一样订单即便用到了同一个类也不干扰。不过根据你们的回复意见LockString并不适合锁。

　　3. Lock(Object)

Lock(Object)和Lock(this)同样，由于根本缘由2者方式是相同的。推荐！

　　4. Lock(StaticObject)

　Lock(StaticObject) 实现了对于同一笔的订单线程互斥，可是不符合的是对于不一样笔的订单一样进行了互斥。

　　结论一目了然，理论的内容不赘述。下面贴代码
`
class Program
{
const string firstOrderId = "001";
const string secondOrderId = "002";
const string thirdOrderId = "003";

static void Main()
    {
        test(LockType.LockThis);
        //test(LockType.LockString);
        //test(LockType.LockObject);
        //test(LockType.LockStaticObject);

        Console.ReadLine();
    }

    static void test(LockType lockType)
    {
        Console.ForegroundColor = ConsoleColor.Yellow;
        Console.WriteLine("------------测试相同订单------------");
        Console.ForegroundColor = ConsoleColor.White;
        OrderPay(firstOrderId, 1, lockType);
        OrderPay(firstOrderId, 2, lockType);
        OrderPay(firstOrderId, 3, lockType);
        Thread.Sleep(10000);

        Console.ForegroundColor = ConsoleColor.Yellow;
        Console.WriteLine("------------测试不一样订单------------");
        Console.ForegroundColor = ConsoleColor.White;
        OrderPay(firstOrderId, 1, lockType);
        OrderPay(secondOrderId, 1, lockType);
        OrderPay(thirdOrderId, 1, lockType);
    }

    static void OrderPay(string orderId, int threadNo, LockType lockType)
    {
        new Thread(() => new Payment(orderId, threadNo).Pay(lockType)).Start();

        Thread.Sleep(10);
    }
}

　　

public class Payment
{
    private readonly string LockString;
    public readonly int ThreadNo;
    private readonly Object LockObj = new object();
    private static readonly Object StaticLockObj = new object();

    public Payment(string orderID, int threadNo)
    {
        LockString = orderID;
        ThreadNo = threadNo;
    }

    public void Pay(LockType lockType)
    {
        ShowMessage("等待锁资源");
        switch (lockType)
        {
            case LockType.LockThis:
                lock (this)
                {
                    showAction();
                }
                break;
            case LockType.LockString:
                lock (LockString)
                {
                    showAction();
                }
                break;
            case LockType.LockObject:
                lock (LockObj)
                {
                    showAction();
                }
                break;
            case LockType.LockStaticObject:
                lock (StaticLockObj)
                {
                    showAction();
                }
                break;
        }
        ShowMessage("释放锁");
    }

    private void showAction()
    {
        ShowMessage("进入锁并开始操做");
        Thread.Sleep(2000);
        ShowMessage("操做完成,完成时间为" + DateTime.Now);
    }

    private void ShowMessage(string message)
    {
        Console.WriteLine(String.Format("订单{0}的第{1}个线程 {2}", LockString, ThreadNo, message));
    }

}

public enum LockType
{
    LockThis = 0,
    LockString = 1,
    LockObject = 2,
    LockStaticObject = 3
}
`
但愿对你们有帮助。