北京遇上西雅图之：当记账系统遇上并发

目前在开发的系统中有个结算的逻辑，每张订单到了账期日后，平台会给商家进行结算。涉及到账户方面的操作包括，平台账户余额的扣减和商户账户余额的增加，以及账户流水的记录。

像这个场景，如果不考虑并发的话，那么很容易出现数据不一致，导致记账混乱。 当然，这是比(xiāng)较(dāng)要命的！

那怎么解决这种并发呢？

 

 

为了便于描述，我们把场景简单化：db里有个t_info_meraccount表，记录平台及商户的账户信息； 程序逻辑为读取出指定的账户记录，修改其某个字段的值。 在这个场景下我们看并发如何处理。

想必大家都可以想到了，用lock。lock将语句块标记为临界区，获取给定对象的互斥锁，然后执行语句块，执行完成后释放锁。 这样可以控制进程内多线程的并发。

 

这里， 我再说另一种也许更好的方法————借助一个时间戳用乐观锁。先看代码逻辑：

public void MyBiz(string name = "")
{
    Stopwatch watch = new Stopwatch();
    watch.Start();

    int loops = 0;//用以记录循环次数
    int i = 0;
    while (i == 0)//在执行db的update时，成功update会返回1，否则（非异常情况下）会返回0。所以，每当返回0时，我们就尝试再次执行整个逻辑
    {
        loops++;

        #region 业务逻辑
        // 1. 读
        var dal = new GateWay.DAL.PriceDal.PriceDAL();
        string mercode = "000001";
        t_info_meraccount accountModel = dal.GetAcInfo(mercode);
        if (name == "")
        {
            accountModel.MerName = accountModel.MerName + loops;
        }
        else
        {
            accountModel.MerName = name;
        }

        // 为了模拟并发，这里让线程随机sleep
        Thread.Sleep(new Random().Next(10, 1000));

        // 2. 写
        i = Update(accountModel);
        #endregion

        if (i == 0)
        {
            Console.WriteLine(Thread.CurrentThread.Name + " 遭遇i=0，接着重试...");
        }
    }
    watch.Stop();
    Console.WriteLine(Thread.CurrentThread.Name + " 执行次数：" + loops + " duation：" + watch.ElapsedMilliseconds);
}

private static int Update(t_info_meraccount model)
{
    string sql = "update t_info_meraccount set MerName=@name,LastTime=@LastTime where AcCode=@AcCode and LastTime=@LastTime1";
    int i = 0;
    using (var conn = ConnUtility.GateWayConntion)
    {
        conn.Open();
        i = conn.Execute(sql, new
        {
            name = model.MerName,
            LastTime = CommonDataType_DateTime.GetTimeStamp(false),
            AcCode = model.AcCode,
            LastTime1 = model.LastTime
        });
        return i;
    }
}

可以看到，代码逻辑即是先select一条记录，然后update改其MerName属性值， 然后将这个修改持久化到db。

也可以看到，这段程序里利用了时间戳。表t_info_meraccount里有个时间戳字段LastTime varchar(20)。 程序在对表执行update操作时，除了update所需的字段外，还要update这个LastTime；另外，where子句中除了必要的AcCode条件外，再追加一个LastTime。可以看到，当LastTime被其他线程/进程更改后就匹配不上了，就会update失败，从而返回0。 那么这时， while循环继续， 重复执行select和update，直到update返回1为止。

是否合理呢？ 我们来写个testcase，模拟多线程并发操作：

[TestMethod]
public void TestConcurrency()
{
    MyBiz("20161129测试商户");
    Thread.Sleep(1000);
    List<Thread> ths = new List<Thread>();
    for (int i = 0; i < 10; i++)
    {
        var thread = new Thread(() =>
        {
            try
            {
                MyBiz();
            }
            catch (Exception ex)
            {
                Console.WriteLine(Thread.CurrentThread.Name + "--" + ex.Message);
            }
        });
        thread.Name = "thread" + i;
        ths.Add(thread);
    }
    ths.ForEach(t => t.Start());
    Thread.Sleep(10 * 1000);

    //Thread.Sleep(1000);
    //Test("20161129测试商户");
}

测试输出：

>	 执行次数：1 duation：1127
>	thread1 执行次数：1 duation：162
>	thread7 遭遇i=0，接着重试...
>	thread8 遭遇i=0，接着重试...
>	thread9 遭遇i=0，接着重试...
>	thread6 遭遇i=0，接着重试...
>	thread2 遭遇i=0，接着重试...
>	thread9 执行次数：2 duation：140
>	thread8 遭遇i=0，接着重试...
>	thread6 遭遇i=0，接着重试...
>	thread7 遭遇i=0，接着重试...
>	thread2 遭遇i=0，接着重试...
>	thread3 遭遇i=0，接着重试...
>	thread3 执行次数：2 duation：699
>	thread5 遭遇i=0，接着重试...
>	thread7 遭遇i=0，接着重试...
>	thread2 遭遇i=0，接着重试...
>	thread6 遭遇i=0，接着重试...
>	thread8 遭遇i=0，接着重试...
>	thread0 遭遇i=0，接着重试...
>	thread4 遭遇i=0，接着重试...
>	thread5 执行次数：2 duation：1146
>	thread2 遭遇i=0，接着重试...
>	thread7 遭遇i=0，接着重试...
>	thread0 遭遇i=0，接着重试...
>	thread4 遭遇i=0，接着重试...
>	thread2 执行次数：5 duation：1398
>	thread7 遭遇i=0，接着重试...
>	thread6 遭遇i=0，接着重试...
>	thread8 遭遇i=0，接着重试...
>	thread7 执行次数：6 duation：1630
>	thread0 遭遇i=0，接着重试...
>	thread4 遭遇i=0，接着重试...
>	thread0 执行次数：4 duation：2081
>	thread4 遭遇i=0，接着重试...
>	thread6 遭遇i=0，接着重试...
>	thread8 遭遇i=0，接着重试...
>	thread8 执行次数：6 duation：2587
>	thread6 遭遇i=0，接着重试...
>	thread4 遭遇i=0，接着重试...
>	thread6 执行次数：7 duation：2825
>	thread4 执行次数：6 duation：3328

查询数据库，t_info_meraccount里AcCode = "000001"的账户的MerName="20161129测试商户1222564676"。 可见，验证了我们代码是ok的。

 

这种利用数据库乐观锁的方式也有效地处理了并发。 那么，和lock相比，它的优势在哪里呢？　ｌｏｃｋ只能控制同一进程内线程。 当这段程序部署在不同的主机上时，lock就显得疲软了。 而后者这个方案，正好解决了多机部署时的并发。

 

最后，附上时间戳的生成算法：

/// <summary>  
/// 获取当前时间戳  
/// </summary>  
/// <param name="bflag">为真时获取10位时间戳,为假时获取13位时间戳.</param>  
/// <returns></returns>  
public static string GetTimeStamp(bool bflag = true)
{
    TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
    string ret = string.Empty;
    if (bflag)
        ret = Convert.ToInt64(ts.TotalSeconds).ToString();
    else
        ret = Convert.ToInt64(ts.TotalMilliseconds).ToString();

    return ret;
}