目前在开发的系统中有个结算的逻辑，每张订单到了账期日后，平台会给商家进行结算。涉及到账户方面的操作包括，平台账户余额的扣减和商户账户余额的增加，以及账户流水的记录。
像这个场景，如果不考虑并发的话，那么很容易出现数据不一致，导致记账混乱。 当然，这是比(xiāng)较(dāng)要命的！
那怎么解决这种并发呢？
为了便于描述，我们把场景简单化：db里有个Account表，记录平台及商户的账户信息； 程序逻辑为读取出指定的账户记录，修改其某个字段的值。 在这个场景下我们看并发如何处理。
想必大家都可以想到了，用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, "1", "3");
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;
}
}
可以看到，代码逻辑即是先取出一条记录，然后修改其MerName属性值， 然后将这个修改持久化到db。
也可以看到，这段程序里利用了时间戳。在表t_info_meraccount里有个时间戳字段LastTime varchar(20)。 在对表执行update时，where子句除了必要的AcCode条件外，再追加一个LastTime。可以看到，当LastTime被其他线程更改后就匹配不上了，就会update失败，从而返回0。 那么这时， while循环继续， 直到返回1为止。
是否合理呢？ 我们来写个testcase，模拟多线程并发操作：
[TestMethod]
public void TestConcurrency()
{
MyBiz("测试商户");
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("测试商户");
}
测试输出：
执行次数：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
db里MerName字段的初始值是“测试商户”，执行testcase后值是“测试商户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;
}