目前在开发的系统中有个结算的逻辑，每张订单到了账期日后，平台会给商家进行结算。涉及到账户方面的操作包括，平台账户余额的扣减和商户账户余额的增加，以及账户流水的记录。
像这个场景，如果不考虑并发的话，那么很容易出现数据不一致，导致记账混乱。 当然，这是比(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; }