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

经常遇到并发修改同一条数据的某个值，

比如：多个用户同时购买同个商品, 扣商品库存时、多个用户同时向一个用户返利, 给此用户加余额时等

此时会产生多个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. 数据级锁,相当于数据库中的行级锁
         * 优点:只对出现并发的数据加锁,不影响其他数据.
         *      比如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. 不用锁, 旧值判断重试机制, 其实也是变相的行级锁
         * 优点:所有请求不用排队,并发修改同一个id的请求保证都能成功.
         * 缺点:其实是将并发压力转移到数据库,不适用于海量并发修改同一条数据的场景.
         * **/
        public void Update3(int id, int variation)
        {
            var rd = new Random();
            while (true)
            {
                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 and money = @oldMoney";
                var c = db.Excute(sql2, new { newMoney, id, oldMoney });
                //如果受影响行数大于0就是更新成功了
                if (c > 0) break;
                //否则就是数据已经被别人更新过了,随机等待几百毫秒重试
                else Task.Delay(rd.Next(100, 1500)).Wait();
            }
        }

搜索

复制