并发加减余额，同时修改同一条数据解决方案

经常遇到并发修改同一条数据的某个值，
比如：多个用户同时购买同个商品, 扣商品库存时、多个用户同时向一个用户返利, 给此用户加余额时 等
此时会产生多个update同一个用户余额，如何保证并发情况下正确修改数据。
要么在数据库里想办法, 在数据库中加锁.
要么在程序中想办法, 下面是我总结的在程序中应对的几个方案, 只适用于单系统单数据库, 如果是分布式系统和分布式数据库要继续修改.

/*
* 1. 直接整个方法加锁
* 优点:简单粗暴,保证每一个udpate都是对的.基本不会出现并发或者偶尔才会出现小规模并发的场景可以使用.
* 缺点:如果业务复杂,经常出现并发的系统,则不能满足需求.
*      比如如果有100个用户同时要修改自己的余额，那就只能排队慢慢等，一个一个修改，越靠后的用户等待时间越长。
* **/
private static readonly object obj1 = new object();
public void Update1(int id, int variation)
{
   //直接对整个方法加锁
   lock (obj1)
   {
       //先把旧的余额查出来
       var sql1 = "select money from table1 where id = @id";
       var oldMoney = db.Excute(sql1, new { id });
       //计算新的余额, 旧的余额加上变化值
       var newMoney = oldMoney + variation;
       //更新余额
       var sql2 = "update table1 set money = @newMoney where id = @id";
       db.Excute(sql2, new { newMoney, id });
   }
}


/*
* 2. 利用Hashtable的特性实现一个数据级锁,相当于数据库中的行级锁
* 优点:只对出现并发的数据加锁,不影响其他数据.
*      比如100个并发请求进来,90个请求要修改的id是各不相同的,10个请求要改同一个id,
*      则只有这10个改同一个id的请求会排队挨个执行,其他的90个请求则不用排队.
* 缺点:如果要修改的id越来越多,Hashtable对象内存占用会越来越大，
* 如果你的系统很少更新并且并发数据量特别大，并且宿主程序没有自动释放机制，那你要手动在代码里加上定时自动释放机制.
* **/
//创建一个Hashtable,id作为key,new一个内存地址作为value
private static Hashtable olock = Hashtable.Synchronized(new Hashtable());
public void Update2(int id, int variation)
{
   //判断key是否存在,这里的Add是线程安全的
   if (!olock.ContainsKey(id)) olock.Add(id, new object());
   //再判断key对应的value是否为空
   else if (olock[id] == null) olock[id] = new object();
   //对id对应的value加锁
   lock (olock[id])
   {
       var sql1 = "select money from table1 where id = @id";
       var oldMoney = db.Excute(sql1, new { id });
       var newMoney = oldMoney + variation;
       var sql2 = "update table1 set money = @newMoney where id = @id";
       db.Excute(sql2, new { newMoney, id });
   }
}


/*
* 3. 不用锁, 旧值判断重试机制, 其实也是变相的行级锁。这种方案会遇到一个ABA问题，加个时间戳或版本号字段即可解决，主要是这个思路。
* 优点:所有请求不用排队,并发修改同一个id的请求保证都能成功，这种方案适合虽然总的并发量特别大，但是是均匀分布到不同数据上的，针对单条数据的并发量中等以下。
* 缺点:其实是将并发压力转移到数据库，如果你的业务针对单条数据的并发量特别大，而数据库配置比较低的话，则很可能遇到数据库性能瓶颈。
* **/
public void Update3(int id, int variation)
{
   var rd = new Random();
   while (true)
   {
   	   //tick是上一次更新money时间戳
       var sql1 = "select money, tick from table1 where id = @id";
       var oldMoney, tick = db.Excute(sql1, new { id });
       var newMoney = oldMoney + variation;
       var sql2 = "update table1 set money = @newMoney where id = @id and money = @oldMoney and tick = @tick";
       var c = db.Excute(sql2, new { newMoney, id, oldMoney, tick });
       //如果受影响行数大于0就是更新成功了，这里也可以将修改前和后的值返回出去
       if (c > 0) break;
       //否则就是数据已经被别人更新过了,随机等待几百毫秒重试
       else Task.Delay(rd.Next(100, 1500)).Wait();
   }
}

第二种方案在C#中还有一个SemaphoreSlim类也能实现同样的效果，直接看代码：

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

namespace SemaphoreSlimTest;

public class Class1
{
    //业务逻辑方法
    public static int count = 0;
    public void bz_func()
    {
        count++;
    }

    //把业务逻辑方法包一层，加锁，一次只能一个线程进入
    private static SemaphoreSlim semaphore = new SemaphoreSlim(1);
    public void bz_func_lock()
    {
        semaphore.Wait(); //一次只能有一个线程继续往下执行，其它线程停在这里等待
        //await semaphore.WaitAsync(); //异步方法
        try
        {
            bz_func();
        }
        finally
        {
            semaphore.Release(); //释放信号量，通知前面semaphore.Wait等待处下一个线程继续往下执行
        }
    }

    //测试，开100个线程同时去改这个值，模拟并发修改同一个字段
    public void Test()
    {
        var tasks = new List<Task>();
        for (int i = 0; i < 100; i++)
        {
            tasks.Add(Task.Factory.StartNew(() =>
            {
                //bz_func(); //不加锁最后输出最终值大概率不是100
                bz_func_lock(); //最终值一定是100
                Thread.Sleep(new Random().Next(100));
            }));
        }
        //等待100个线程全部执行完，输出最终值
        Task.WaitAll(tasks.ToArray());
        Console.WriteLine(count);
    }


}

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

namespace SemaphoreSlimTest;

public class Class2
{
    //业务逻辑方法
    public static int count = 0;
    public void bz_func(int id)
    {
        count++;
    }

    //一般都是根据id去更新数据，为每一个id生成一个SemaphoreSlim对象, 绑定放入线程安全字典，这样不同的id可以并发执行
    static ConcurrentDictionary<int, SemaphoreSlim> semaphoreDictionary = new ConcurrentDictionary<int, SemaphoreSlim>();
    public void bz_func_lock(int id)
    {
        var semaphore = semaphoreDictionary.GetOrAdd(id, _ => new SemaphoreSlim(1)); //GetOrAdd方法是线程安全的
        semaphore.Wait(); //一次只能有一个线程继续往下执行，其它线程停在这里等待
        //await semaphore.WaitAsync(); //异步方法
        try
        {
            bz_func(id);
        }
        finally
        {
            semaphore.Release(); //释放信号量，通知前面semaphore.Wait等待处下一个线程继续往下执行
        }
    }

    //测试，开100个线程同时去改这个值，模拟并发修改同一个字段
    public void Test()
    {
        var tasks = new List<Task>();
        for (int i = 0; i < 100; i++)
        {
            tasks.Add(Task.Factory.StartNew(() =>
            {
                //bz_func(1); //不加锁最后输出最终值大概率不是100
                bz_func_lock(1); //最终值一定是100
                Thread.Sleep(new Random().Next(100));
            }));
        }
        //等待100个线程全部执行完，输出最终值
        Task.WaitAll(tasks.ToArray());
        Console.WriteLine(count);
    }


}