(更新时间)2021年6月3日 商城高并发秒杀系统(.NET Core版) 25-性能优化-秒杀库存优化(本地缓存)

举报
愚公搬代码 发表于 2021/10/18 22:59:02 2021/10/18
【摘要】 一:相关依赖包 Microsoft.Extensions.Caching.Memory 12 使用 services.AddMemoryCache(); 1 private readonly ...

一:相关依赖包

Microsoft.Extensions.Caching.Memory


  
 
  • 1
  • 2

使用

services.AddMemoryCache();

  
 
  • 1
 private readonly IMemoryCache memoryCache;
 public OrderController( IMemoryCache memoryCache)
 {
     this.memoryCache = memoryCache;
 }

  
 
  • 1
  • 2
  • 3
  • 4
  • 5

二:开机启动时加载秒杀库存到缓存中

相关缓存扩展类

/// <summary>
/// 秒杀缓存接口
/// </summary>
public interface ISeckillStockCache
{
    /// <summary>
    /// 秒杀库存加载到缓存中
    /// </summary>
    public void SkillStockToCache();

    /// <summary>
    /// 根据商品编号获取秒杀库存
    /// </summary>
    public int GetSeckillStocks(int ProductId);

    /// <summary>
    /// 扣减秒杀库存
    /// </summary>
    /// <param name="ProductId"></param>
    /// <param name="ProductCount"></param>
    public void SubtractSeckillStock(int ProductId, int ProductCount);
}

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
/// <summary>
/// 秒杀库存redis缓存
/// </summary>
public class RedisSeckillStockCache : ISeckillStockCache
{
    /// <summary>
    /// 秒杀微服务客户端
    /// </summary>
    private readonly ISeckillsClient seckillsClient;
    private readonly IMemoryCache memoryCache;

    public RedisSeckillStockCache(ISeckillsClient seckillsClient, IMemoryCache memoryCache)
    {
        this.seckillsClient = seckillsClient;
        this.memoryCache = memoryCache;
    }

    public int GetSeckillStocks(int ProductId)
    {
       return Convert.ToInt32(RedisHelper.HGet(Convert.ToString(ProductId), "SeckillStock"));
    }

    /// <summary>
    /// 秒杀库存加载到redis中
    /// </summary>
    public void SkillStockToCache()
    {
        // 1、查询所有秒杀活动
        List<Seckill> seckills = seckillsClient.GetSeckills();

        // 2、加载秒杀商品
        foreach (var seckill in seckills)
        {
            // 3、存数秒杀库存
            bool flag = RedisHelper.HSet(Convert.ToString(seckill.ProductId), "SeckillStock", seckill.SeckillStock);
            // 4、存储限制秒杀购买数量
            bool flag2 = RedisHelper.HSet(Convert.ToString(seckill.ProductId), "SeckillLimit", seckill.SeckillLimit);

            // 3.1 存储到redis失败
            /*if (!flag && !flag2)
            {
                throw new BizException("redis存储数据失败");
            }*/

            // flag // flag2 判断key是否存在
        }
    }

    /// <summary>
    /// redis扣减库存
    /// </summary>
    /// <param name="ProductId"></param>
    /// <param name="ProductCount"></param>
    public void SubtractSeckillStock(int ProductId, int ProductCount)
    {
        // 1、判断库存是否扣减完成
        long seckillStock = RedisHelper.HIncrBy(Convert.ToString(ProductId), "SeckillStock", -ProductCount);
        if (seckillStock < 0)
        {
            throw new BizException("秒杀已结束");
        }
    }
}

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
/// <summary>
/// 秒杀库存缓存
/// </summary>
public class SeckillStockCache : ISeckillStockCache
{
    /// <summary>
    /// 秒杀微服务客户端
    /// </summary>
    private readonly ISeckillsClient seckillsClient;
    /// <summary>
    /// 内存缓存
    /// </summary>
    private readonly IMemoryCache memoryCache;

    public SeckillStockCache(ISeckillsClient seckillsClient, IMemoryCache memoryCache)
    {
        this.seckillsClient = seckillsClient;
        this.memoryCache = memoryCache;
    }

    public int GetSeckillStocks(int ProductId)
    {
        Seckill seckillStock = memoryCache.Get<Seckill>(ProductId);
        return seckillStock.SeckillStock;
    }

    /// <summary>
    /// 秒杀库存加载到MemoryCache中
    /// </summary>
    public void SkillStockToCache()
    {
        // 1、查询所有秒杀活动
        List<Seckill> seckills = seckillsClient.GetSeckills();

        // 2、存储秒杀库存到缓存
        foreach (var seckill in seckills)
        {
            // 2.1 将所有秒杀活动存储到缓存中
            memoryCache.Set<Seckill>(seckill.ProductId, seckill);
        }
    }

    public void SubtractSeckillStock(int ProductId, int ProductCount)
    {
        // 1、获取秒杀活动信息
        Seckill seckill = memoryCache.Get<Seckill>(ProductId);

        // 2、扣减库存
        int SeckillStock = seckill.SeckillStock;
        SeckillStock = seckill.SeckillStock - ProductCount;
        seckill.SeckillStock = SeckillStock;

        // 3、更新库存
        memoryCache.Set<Seckill>(seckill.ProductId, seckill);

        Seckill seckill2 = memoryCache.Get<Seckill>(ProductId);
    }
}

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
/// <summary>
/// 服务启动时,加载秒杀库存到缓存
/// </summary>
public class SeckillStockCacheHostedService : IHostedService
{
    private readonly ISeckillStockCache seckillStockCache;

    public SeckillStockCacheHostedService(ISeckillStockCache seckillStockCache)
    {
        this.seckillStockCache = seckillStockCache;
    }

    /// <summary>
    /// 加载秒杀库存缓存
    /// </summary>
    /// <param name="cancellationToken"></param>
    /// <returns></returns>
    public Task StartAsync(CancellationToken cancellationToken)
    {
        Console.WriteLine("加载秒杀库存到缓存中");
        return Task.Run(() => seckillStockCache.SkillStockToCache());
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        return Task.CompletedTask;
    }
}

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
/// <summary>
/// 秒杀库存使用IOC容器触发
/// </summary>
public static class SeckillStockCacheServiceCollectionExtensions
{
    /// <summary>
    /// 添加秒杀库存到Cache
    /// </summary>
    /// <returns></returns>
    public static IServiceCollection AddSeckillStockCache(this IServiceCollection services)
    {
        // 1、注册SeckillStockCache
        services.AddSingleton<ISeckillStockCache,SeckillStockCache>();

        // 2、注册SeckillStockCacheHostedService
        services.AddHostedService<SeckillStockCacheHostedService>();
        return services;
    }

    /// <summary>
    /// 添加秒杀库存到redis
    /// </summary>
    /// <returns></returns>
    public static IServiceCollection AddRedisSeckillStockCache(this IServiceCollection services)
    {
        // 1、注册SeckillStockCache
        services.AddSingleton<ISeckillStockCache, RedisSeckillStockCache>();

        // 2、注册SeckillStockCacheHostedService
        services.AddHostedService<SeckillStockCacheHostedService>();
        return services;
    }

}

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

使用

// 6、使用内存缓存
services.AddMemoryCache();
// 6.1 使用redis分布式缓存
// services.AddDistributedRedisCache("127.0.0.1:6379, password =, defaultDatabase = 2, poolsize = 50, connectTimeout = 5000, syncTimeout = 10000, prefix = seckill_stock_:");
//services.AddDistributedRedisCache("172.18.0.19:6379, password =, defaultDatabase = 2, poolsize = 50, connectTimeout = 5000, syncTimeout = 10000, prefix = seckill_stock_");
services.AddDistributedRedisCache("10.96.0.6:6379, password =, defaultDatabase = 2, poolsize = 50, connectTimeout = 5000, syncTimeout = 10000, prefix = seckill_stock_");// k8s redis

// 7、使用秒杀库存缓存
// services.AddSeckillStockCache();
// 7.1 使用秒杀redis库存缓存
services.AddRedisSeckillStockCache();

  
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

三:性能优化效果

未优化前:170 请求并发 2.5s
优化后:340请求 并发 1.3s

  
 
  • 1
  • 2

文章来源: codeboy.blog.csdn.net,作者:愚公搬代码,版权归原作者所有,如需转载,请联系作者。

原文链接:codeboy.blog.csdn.net/article/details/117486575

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。