devbox
很楠不爱3
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

面试中又被问到Redis如何实现抢购，赶快代码实现一波吧！

作者：很楠不爱3 | 2024-05-22 04:21:36

赞

踩

redis题目抢答 java如何实现

作者：goodlook0123

https://blog.csdn.net/goodlook0123

面试常常遇到写一个抢购实例，或者讲讲抢购实现想法，然后总是讲不明白，因为目前工作没做抢购这一块儿。

但是这个想法今天终于搞明白了，其中也参照了一些大佬的做法。

这篇文章直接使用redis，其中注释也写的挺明白的，直接上代码：

junit测试类：

  1. Log log = LogFactory.getLog(getClass());
  2.  
  3.     @Autowired  
  4.     private RedisTemplate<String, Object> redisTemplate;  
  5.  
  6.     @Test
  7.     public void testSys() throws Exception{
  8.         log.info("开始");
  9.  
  10.          MsService service = new MsService();
  11.  
  12.          for (int i = 0; i < 10; i++) {
  13.              ThreadB threadA = new ThreadB(service, redisTemplate, "MSKEY");
  14.              threadA.start();
  15.              log.info("*******************结束");
  16.          }
  17.  
  18.     }

threadB类：

  1. private MsService service;
  2.     private RedisTemplate<String,Object> redisTemplate;
  3.     private String key;
  4.  
  5.     public ThreadB(MsService service,RedisTemplate<String,Object> redisTemplate,String key) {
  6.         this.service = service;
  7.         this.redisTemplate=redisTemplate;
  8.         this.key=key;
  9.     }
  10.  
  11.     @Override
  12.     public void run() {
  13.         try {
  14.             service.seckill(redisTemplate, key);
  15.         } catch (InterruptedException e) {
  16.             // TODO Auto-generated catch block
  17.             e.printStackTrace();
  18.         } catch (Exception e) {
  19.             // TODO Auto-generated catch block
  20.             e.printStackTrace();
  21.         }
  22.     }

msService类：

  1. Log log = LogFactory.getLog(getClass());
  2.  
  3.      /***
  4.      * 抢购代码
  5.      * @param redisTemplate
  6.      * @param key pronum 首先用客户端设置数量
  7.      * @return
  8.      * @throws InterruptedException 
  9.      */
  10.     public boolean seckill(RedisTemplate<String,Object> redisTemplate, String key) throws Exception {
  11.         RedisLock lock = new RedisLock(redisTemplate, key, 10000, 20000);
  12.         try {
  13.             if (lock.lock()) {
  14.                 // 需要加锁的代码
  15.                 String pronum=lock.get("pronum");
  16.                 //修改库存
  17.                 if(Integer.parseInt(pronum)-1>=0) {
  18.                     lock.set("pronum",String.valueOf(Integer.parseInt(pronum)-1));
  19.                     log.info("库存数量:"+pronum+"     成功!!!"+Thread.currentThread().getName());
  20.                 }else {
  21.                     log.info("已经被抢光了，请参与下轮抢购");
  22.                 }
  23.                 log.info("++++++++++++++++++++++++++++++++++++++参加了抢购");
  24.                 return true;
  25.             } 
  26.  
  27.  
  28.         } catch (InterruptedException e) {
  29.             e.printStackTrace();
  30.         } finally {
  31.             // 为了让分布式锁的算法更稳键些，持有锁的客户端在解锁之前应该再检查一次自己的锁是否已经超时，再去做DEL操作，因为可能客户端因为某个耗时的操作而挂起，
  32.             // 操作完的时候锁因为超时已经被别人获得，这时就不必解锁了。 ————这里没有做
  33.             lock.unlock();
  34.         }
  35.         return false;
  36.     }

redisLock类：

  1. public class RedisLock {
  2.  
  3.     private static Logger logger = LoggerFactory.getLogger(RedisLock.class);
  4.  
  5.     private RedisTemplate<String,Object> redisTemplate;
  6.  
  7.     private static final int DEFAULT_ACQUIRY_RESOLUTION_MILLIS = 100;
  8.  
  9.     /**
  10.      * Lock key path.
  11.      */
  12.     private String lockKey;
  13.  
  14.     /**
  15.      * 锁超时时间，防止线程在入锁以后，无限的执行等待
  16.      */
  17.     private int expireMsecs = 60 * 1000;
  18.  
  19.     /**
  20.      * 锁等待时间，防止线程饥饿
  21.      */
  22.     private int timeoutMsecs = 10 * 1000;
  23.  
  24.     private volatile boolean locked = false;
  25.  
  26.     /**
  27.      * Detailed constructor with default acquire timeout 10000 msecs and lock
  28.      * expiration of 60000 msecs.
  29.      *
  30.      * @param lockKey
  31.      *            lock key (ex. account:1, ...)
  32.      */
  33.     public RedisLock(RedisTemplate<String,Object> redisTemplate, String lockKey) {
  34.         this.redisTemplate = redisTemplate;
  35.         this.lockKey = lockKey + "_lock";
  36.     }
  37.  
  38.     /**
  39.      * Detailed constructor with default lock expiration of 60000 msecs.
  40.      *
  41.      */
  42.     public RedisLock(RedisTemplate<String,Object> redisTemplate, String lockKey, int timeoutMsecs) {
  43.         this(redisTemplate, lockKey);
  44.         this.timeoutMsecs = timeoutMsecs;
  45.     }
  46.  
  47.     /**
  48.      * Detailed constructor.
  49.      *
  50.      */
  51.     public RedisLock(RedisTemplate<String,Object> redisTemplate, String lockKey, int timeoutMsecs, int expireMsecs) {
  52.         this(redisTemplate, lockKey, timeoutMsecs);
  53.         this.expireMsecs = expireMsecs;
  54.     }
  55.  
  56.     /**
  57.      * @return lock key
  58.      */
  59.     public String getLockKey() {
  60.         return lockKey;
  61.     }
  62.  
  63.     public String get(final String key) {
  64.         Object obj = null;
  65.         try {
  66.             obj = redisTemplate.execute(new RedisCallback<Object>() {
  67.                 @Override
  68.                 public Object doInRedis(RedisConnection connection) throws DataAccessException {
  69.                     StringRedisSerializer serializer = new StringRedisSerializer();
  70.                     byte[] data = connection.get(serializer.serialize(key));
  71.                     connection.close();
  72.                     if (data == null) {
  73.                         return null;
  74.                     }
  75.                     return serializer.deserialize(data);
  76.                 }
  77.             });
  78.         } catch (Exception e) {
  79.             logger.error("get redis error, key : {}", key);
  80.         }
  81.         return obj != null ? obj.toString() : null;
  82.     }
  83.  
  84.  
  85.     public String set(final String key,final String value) {
  86.         Object obj = null;
  87.         try {
  88.             obj = redisTemplate.execute(new RedisCallback<Object>() {
  89.                 @Override
  90.                 public Object doInRedis(RedisConnection connection) throws DataAccessException {
  91.                     StringRedisSerializer serializer = new StringRedisSerializer();
  92.                     connection.set(serializer.serialize(key), serializer.serialize(value));
  93.                     return serializer;
  94.                 }
  95.             });
  96.         } catch (Exception e) {
  97.             logger.error("get redis error, key : {}", key);
  98.         }
  99.         return obj != null ? obj.toString() : null;
  100.     }
  101.  
  102.     public boolean setNX(final String key, final String value) {
  103.         Object obj = null;
  104.         try {
  105.             obj = redisTemplate.execute(new RedisCallback<Object>() {
  106.                 @Override
  107.                 public Object doInRedis(RedisConnection connection) throws DataAccessException {
  108.                     StringRedisSerializer serializer = new StringRedisSerializer();
  109.                     Boolean success = connection.setNX(serializer.serialize(key), serializer.serialize(value));
  110.                     connection.close();
  111.                     return success;
  112.                 }
  113.             });
  114.         } catch (Exception e) {
  115.             logger.error("setNX redis error, key : {}", key);
  116.         }
  117.         return obj != null ? (Boolean) obj : false;
  118.     }
  119.  
  120.     private String getSet(final String key, final String value) {
  121.         Object obj = null;
  122.         try {
  123.             obj = redisTemplate.execute(new RedisCallback<Object>() {
  124.                 @Override
  125.                 public Object doInRedis(RedisConnection connection) throws DataAccessException {
  126.                     StringRedisSerializer serializer = new StringRedisSerializer();
  127.                     byte[] ret = connection.getSet(serializer.serialize(key), serializer.serialize(value));
  128.                     connection.close();
  129.                     return serializer.deserialize(ret);
  130.                 }
  131.             });
  132.         } catch (Exception e) {
  133.             logger.error("setNX redis error, key : {}", key);
  134.         }
  135.         return obj != null ? (String) obj : null;
  136.     }
  137.  
  138.     /**
  139.      * 获得 lock. 实现思路: 主要是使用了redis 的setnx命令,缓存了锁. reids缓存的key是锁的key,所有的共享,
  140.      * value是锁的到期时间(注意:这里把过期时间放在value了,没有时间上设置其超时时间) 执行过程:
  141.      * 1.通过setnx尝试设置某个key的值,成功(当前没有这个锁)则返回,成功获得锁
  142.      * 2.锁已经存在则获取锁的到期时间,和当前时间比较,超时的话,则设置新的值
  143.      *
  144.      * @return true if lock is acquired, false acquire timeouted
  145.      * @throws InterruptedException
  146.      *             in case of thread interruption
  147.      */
  148.     public synchronized boolean lock() throws InterruptedException {
  149.         int timeout = timeoutMsecs;
  150.         while (timeout >= 0) {
  151.             long expires = System.currentTimeMillis() + expireMsecs + 1;
  152.             String expiresStr = String.valueOf(expires); // 锁到期时间
  153.             if (this.setNX(lockKey, expiresStr)) {
  154.                 // lock acquired
  155.                 locked = true;
  156.                 return true;
  157.             }
  158.  
  159.             String currentValueStr = this.get(lockKey); // redis里的时间
  160.             if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
  161.                 // 判断是否为空，不为空的情况下，如果被其他线程设置了值，则第二个条件判断是过不去的
  162.                 // lock is expired
  163.  
  164.                 String oldValueStr = this.getSet(lockKey, expiresStr);
  165.                 // 获取上一个锁到期时间，并设置现在的锁到期时间，
  166.                 // 只有一个线程才能获取上一个线上的设置时间，因为jedis.getSet是同步的
  167.                 if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
  168.                     // 防止误删（覆盖，因为key是相同的）了他人的锁——这里达不到效果，这里值会被覆盖，但是因为什么相差了很少的时间，所以可以接受
  169.  
  170.                     // [分布式的情况下]:如过这个时候，多个线程恰好都到了这里，但是只有一个线程的设置值和当前值相同，他才有权利获取锁
  171.                     // lock acquired
  172.                     locked = true;
  173.                     return true;
  174.                 }
  175.             }
  176.             timeout -= DEFAULT_ACQUIRY_RESOLUTION_MILLIS;
  177.  
  178.             /*
  179.              * 延迟100 毫秒, 这里使用随机时间可能会好一点,可以防止饥饿进程的出现,即,当同时到达多个进程,
  180.              * 只会有一个进程获得锁,其他的都用同样的频率进行尝试,后面有来了一些进行,也以同样的频率申请锁,这将可能导致前面来的锁得不到满足.
  181.              * 使用随机的等待时间可以一定程度上保证公平性
  182.              */
  183.             Thread.sleep(DEFAULT_ACQUIRY_RESOLUTION_MILLIS);
  184.  
  185.         }
  186.         return false;
  187.     }
  188.  
  189.     /**
  190.      * Acqurired lock release.
  191.      */
  192.     public synchronized void unlock() {
  193.         if (locked) {
  194.             redisTemplate.delete(lockKey);
  195.             locked = false;
  196.         }
  197.     }

至此基于redis的抢购简单实现。大佬如果觉得有不妥的地方请指正，小弟也可以进步一点点。

Java面试题专栏

【71期】面试官：对并发熟悉吗？谈谈你对Java中常用的几种线程池的理解

【72期】面试官：对并发熟悉吗？说一下synchronized与Lock的区别与使用

【73期】面试官：Spring 和 Spring Boot 的区别是什么？

【74期】面试官：对多线程熟悉吗，来谈谈线程池的好处？

【75期】面试官：说说Redis的过期键删除策略吧！（高频）

【76期】面试官问：List如何一边遍历，一边删除？

【77期】这一道面试题就考验了你对Java的理解程度

【78期】别找了，Java集合面试问题这里帮你总结好了！

【79期】别找了，回答Spring中Bean的生命周期，这里帮你总结好了！

【80期】说出Java创建线程的三种方式及对比

欢迎长按下图关注公众号后端技术精选

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/606223
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号