微服务-分布式锁(8)

在微服务中，高并发下，为了保持数据一致性，引入分布式锁的机制来解决问题

准备工作：

以下通过Parallel模拟多线程并发的情景，简单看下Parallel

适用场合：

1）数据并行（数据的重复性操作） Parallel.For

2）任务并行 任务并发运行不同的操作 Parallel.Invoke

3）流水线：任务并行与数据并行

Parallel.Invoke示例如下，定义四个方法BasketBall，FootBall，Tennis，Swim

 static void BasketBall()
{
    Console.WriteLine("BasketBall");
}

static void FootBall()
{
     Console.WriteLine("FootBall");
}

static void Tennis()
{
    Console.WriteLine("Tennis");
}

static void Swim()
{
     Console.WriteLine("Swim");
}
          

Parallel.Invoke无序执行：

 public static void ParallelInvoke()
        {
            Parallel.Invoke(() => BasketBall(), () => FootBall(), () => Tennis(), () => Swim());
            Console.WriteLine("运动完成");
        }

执行两次，结果如下：

 

Parallel.For 为固定数目的独立for循环提供了负载均衡，模拟并发操作

Parallel.For(1, 20, (int i) =>
{
    Task.Run(() =>
    {
        Console.WriteLine($"当前线程Id:{Thread.CurrentThread.ManagedThreadId.ToString("00")},当前序号:{i}"); 
    });
});

结果如下：

正文：

为什么要加锁？主要是为了防止在高并发的情况下，多线程同时处理同一个变量导致数据不准确的问题

(1)不加锁的情况：设置库存量为10

//在Redis中配置
using (var client = new RedisClient("localhost", 6379))
{
    client.Set<int>("StockNum", 10);//库存量10
    client.Set<int>("OrderNum", 0);//订单量0 
}

Parallel.For(1, 10, (i) =>
{
    using (var client = new RedisClient("localhost", 6379))
    {
        int stocknum = client.Get<int>("StockNum");
        if (stocknum > 0)
        {
            //库存量-1
            client.Set<int>("StockNum", stocknum - 1);
            //订单量+1
            long ordernum = client.Incr("OrderNum");
            Console.WriteLine($"当前线程：{Thread.CurrentThread.ManagedThreadId.ToString("00")},库存量：{stocknum},订单量：{ordernum}");
        }
    } 

});

结果如下：库存量还未减少的情况下，重复下单，导致超卖

 (2)加锁，Lock，通过控制共享存储块的状态，使多线程变为单线程处理

using (var client = new RedisClient("localhost", 6379))
    {
        client.Set<int>("StockNum", 10);//库存量10
        client.Set<int>("OrderNum", 0);//订单量0 
    }

    Parallel.For(0, 10, (i) =>
    {
        using (var client = new RedisClient("localhost", 6379))
        {
          
            lock (olock)
            {
                int stocknum = client.Get<int>("StockNum");
                if (stocknum > 0)
                {
                    //库存量-1
                    client.Set<int>("StockNum", stocknum - 1);
                    //订单量+1
                    long ordernum = client.Incr("OrderNum");
                    Console.WriteLine($"当前线程：{Thread.CurrentThread.ManagedThreadId.ToString("00")},库存量：{stocknum},订单量：{ordernum}");
                }
            }
        }
    });

结果如下：可见在多进程情况下，库存量和订单量之和恒定

 (3) 然而目前是微服务项目，多个微服务并不能共享同一个存储块，Lock无法适用于分布式的场景

本次通过设置Redis的Add方法来解决，如果设置的Key已存在，则无法再添加。若不存在，则添加该Key,业务完成后，删除该key,让其他线程重复上述操作

string LockKey = "DistributedLock";

using (var client = new RedisClient("localhost", 6379))
{
    client.Set<int>("StockNum", 10);//库存量10
    client.Set<int>("OrderNum", 0);//订单量0 
}

Parallel.For(0, 10, (i) =>
{
    using (var client = new RedisClient("localhost", 6379))
    {
        //已存在，则返回false
        bool isLock = client.Add(LockKey, LockKey, TimeSpan.FromSeconds(100));
        if (isLock)
        {
            try
            {
                int stocknum = client.Get<int>("StockNum");
                if (stocknum > 0)
                {
                    //库存量-1
                    stocknum--;
                    client.Set<int>("StockNum", stocknum);
                    //订单量+1
                    long ordernum = client.Incr("OrderNum");
                    Console.WriteLine($"当前线程：{Thread.CurrentThread.ManagedThreadId.ToString("00")},库存量：{stocknum},订单量：{ordernum}");
                }
            }
            catch
            {
                throw;
            }
            finally {
                client.Remove(LockKey);
            }
        }
        else 
        {
            Console.WriteLine("未拿到锁！");
        }

    }

});

结果如下：只有拿到锁，才能进行库存和下单的业务操作

 (4)优化未拿到锁时的情景

增加锁的过期时间和等待时间，但会导致请求的阻塞，影响性能，所以对时间的设置要谨慎

以上，仅用于学习和总结！