编程知识 cdmana.com

In the interview, I was asked how redis realized the rush purchase. Let's get the code implemented quickly!

author :goodlook0123

https://blog.csdn.net/goodlook0123

An interview often involves writing an example of a rush purchase , Or talk about the realization of the idea of flash buying , Then I always don't understand , Because I haven't done the rush purchase at present .

But the idea has finally come to light today , It also refers to the practice of some big men .

This article uses redis, The notes are very clear , Go straight to the code :

junit Test class :

Log log = LogFactory.getLog(getClass());

    @Autowired  
    private RedisTemplate<String, Object> redisTemplate;  

    @Test
    public void testSys() throws Exception{
        log.info(" Start ");

         MsService service = new MsService();

         for (int i = 0; i < 10; i++) {
             ThreadB threadA = new ThreadB(service, redisTemplate, "MSKEY");
             threadA.start();
             log.info("******************* end ");
         }

    }

threadB class :

private MsService service;
    private RedisTemplate<String,Object> redisTemplate;
    private String key;

    public ThreadB(MsService service,RedisTemplate<String,Object> redisTemplate,String key) {
        this.service = service;
        this.redisTemplate=redisTemplate;
        this.key=key;
    }

    @Override
    public void run() {
        try {
            service.seckill(redisTemplate, key);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

msService class :

Log log = LogFactory.getLog(getClass());

     /***
     *  Flash code 
     * @param redisTemplate
     * @param key pronum  First set the number with the client 
     * @return
     * @throws InterruptedException 
     */
    public boolean seckill(RedisTemplate<String,Object> redisTemplate, String key) throws Exception {
        RedisLock lock = new RedisLock(redisTemplate, key, 1000020000);
        try {
            if (lock.lock()) {
                //  Code that needs to be locked 
                String pronum=lock.get("pronum");
                // Modify inventory 
                if(Integer.parseInt(pronum)-1>=0) {
                    lock.set("pronum",String.valueOf(Integer.parseInt(pronum)-1));
                    log.info(" Inventory quantity :"+pronum+"      success !!!"+Thread.currentThread().getName());
                }else {
                    log.info(" It's been robbed , Please take part in the next rush ");
                }
                log.info("++++++++++++++++++++++++++++++++++++++ Participated in the rush to buy ");
                return true;
            } 


        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //  In order to make the distributed lock algorithm more stable , The client holding the lock should check again whether its lock has timed out before unlocking , Do it again DEL operation , Because it is possible that the client is suspended due to a time-consuming operation ,
            //  At the end of the operation, the lock has been acquired by someone else due to timeout , There's no need to unlock . ———— It's not done here 
            lock.unlock();
        }
        return false;
    }

redisLock class :

public class RedisLock {

    private static Logger logger = LoggerFactory.getLogger(RedisLock.class);

    private RedisTemplate<String,Object> redisTemplate;

    private static final int DEFAULT_ACQUIRY_RESOLUTION_MILLIS = 100;

    /**
     * Lock key path.
     */
    private String lockKey;

    /**
     *  Lock timeout , Prevent the thread from entering the lock , Infinite execution waiting 
     */
    private int expireMsecs = 60 * 1000;

    /**
     *  Lock wait time , Prevent thread starvation 
     */
    private int timeoutMsecs = 10 * 1000;

    private volatile boolean locked = false;

    /**
     * Detailed constructor with default acquire timeout 10000 msecs and lock
     * expiration of 60000 msecs.
     *
     * @param lockKey
     *            lock key (ex. account:1, ...)
     */
    public RedisLock(RedisTemplate<String,Object> redisTemplate, String lockKey) {
        this.redisTemplate = redisTemplate;
        this.lockKey = lockKey + "_lock";
    }

    /**
     * Detailed constructor with default lock expiration of 60000 msecs.
     *
     */
    public RedisLock(RedisTemplate<String,Object> redisTemplate, String lockKey, int timeoutMsecs) {
        this(redisTemplate, lockKey);
        this.timeoutMsecs = timeoutMsecs;
    }

    /**
     * Detailed constructor.
     *
     */
    public RedisLock(RedisTemplate<String,Object> redisTemplate, String lockKey, int timeoutMsecs, int expireMsecs) {
        this(redisTemplate, lockKey, timeoutMsecs);
        this.expireMsecs = expireMsecs;
    }

    /**
     * @return lock key
     */
    public String getLockKey() {
        return lockKey;
    }

    public String get(final String key) {
        Object obj = null;
        try {
            obj = redisTemplate.execute(new RedisCallback<Object>() {
                @Override
                public Object doInRedis(RedisConnection connection) throws DataAccessException {
                    StringRedisSerializer serializer = new StringRedisSerializer();
                    byte[] data = connection.get(serializer.serialize(key));
                    connection.close();
                    if (data == null) {
                        return null;
                    }
                    return serializer.deserialize(data);
                }
            });
        } catch (Exception e) {
            logger.error("get redis error, key : {}", key);
        }
        return obj != null ? obj.toString() : null;
    }


    public String set(final String key,final String value) {
        Object obj = null;
        try {
            obj = redisTemplate.execute(new RedisCallback<Object>() {
                @Override
                public Object doInRedis(RedisConnection connection) throws DataAccessException {
                    StringRedisSerializer serializer = new StringRedisSerializer();
                    connection.set(serializer.serialize(key), serializer.serialize(value));
                    return serializer;
                }
            });
        } catch (Exception e) {
            logger.error("get redis error, key : {}", key);
        }
        return obj != null ? obj.toString() : null;
    }

    public boolean setNX(final String key, final String value) {
        Object obj = null;
        try {
            obj = redisTemplate.execute(new RedisCallback<Object>() {
                @Override
                public Object doInRedis(RedisConnection connection) throws DataAccessException {
                    StringRedisSerializer serializer = new StringRedisSerializer();
                    Boolean success = connection.setNX(serializer.serialize(key), serializer.serialize(value));
                    connection.close();
                    return success;
                }
            });
        } catch (Exception e) {
            logger.error("setNX redis error, key : {}", key);
        }
        return obj != null ? (Boolean) obj : false;
    }

    private String getSet(final String key, final String value) {
        Object obj = null;
        try {
            obj = redisTemplate.execute(new RedisCallback<Object>() {
                @Override
                public Object doInRedis(RedisConnection connection) throws DataAccessException {
                    StringRedisSerializer serializer = new StringRedisSerializer();
                    byte[] ret = connection.getSet(serializer.serialize(key), serializer.serialize(value));
                    connection.close();
                    return serializer.deserialize(ret);
                }
            });
        } catch (Exception e) {
            logger.error("setNX redis error, key : {}", key);
        }
        return obj != null ? (String) obj : null;
    }

    /**
     *  get  lock.  Realize the idea :  Mainly used redis  Of setnx command , Cache lock . reids The cache key It's locked key, All the sharing ,
     * value It's the expiration time of the lock ( Be careful : Let's put the expiration date here value 了 , There's no time to set its timeout )  Execution process :
     * 1. adopt setnx Try to set something up key Value , success ( There is no such lock at present ) Then return to , Successful lock acquisition 
     * 2. Get the expiration time of the lock if the lock already exists , Compare it to the current time , If the timeout , Then set the new value 
     *
     * @return true if lock is acquired, false acquire timeouted
     * @throws InterruptedException
     *             in case of thread interruption
     */
    public synchronized boolean lock() throws InterruptedException {
        int timeout = timeoutMsecs;
        while (timeout >= 0) {
            long expires = System.currentTimeMillis() + expireMsecs + 1;
            String expiresStr = String.valueOf(expires); //  Lock expiration time 
            if (this.setNX(lockKey, expiresStr)) {
                // lock acquired
                locked = true;
                return true;
            }

            String currentValueStr = this.get(lockKey); // redis Time in 
            if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
                //  Determine whether it is null , Not empty , If the value is set by another thread , Then the second condition is not to pass 
                // lock is expired

                String oldValueStr = this.getSet(lockKey, expiresStr);
                //  Get last lock expiration time , And set the current lock expiration time ,
                //  Only one thread can get the setting time of the previous line , because jedis.getSet It's synchronous 
                if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
                    //  Prevent false deletion ( Cover , because key It's the same ) Someone else's lock —— It doesn't work here , Here the value will be overridden , But because there is little time difference , So it's acceptable 

                    // [ In the case of distributed ]: If after this time , Multiple threads happen to be here , But only one thread has the same set value as the current one , He has the right to a lock 
                    // lock acquired
                    locked = true;
                    return true;
                }
            }
            timeout -= DEFAULT_ACQUIRY_RESOLUTION_MILLIS;

            /*
             *  Delay 100  millisecond ,  It might be better to use random time here , Can prevent the emergence of hunger process , namely , When multiple processes arrive at the same time ,
             *  Only one process gets the lock , The others are trying on the same frequency , There's some going on in the back , Apply for locks at the same frequency , This may result in the front lock not being satisfied .
             *  Using random waiting time can guarantee fairness to some extent 
             */
            Thread.sleep(DEFAULT_ACQUIRY_RESOLUTION_MILLIS);

        }
        return false;
    }

    /**
     * Acqurired lock release.
     */
    public synchronized void unlock() {
        if (locked) {
            redisTemplate.delete(lockKey);
            locked = false;
        }
    }

This is based on redis It's easy to implement . If you think there is something wrong, please correct , Little brother can also improve a little bit .

 Recommended reading 


 Code comparison tool , I'll use this 6 individual 

 Share my favorite 5 A free online  SQL  Database environment , It's so convenient !

Spring Boot  A combination of three moves , Hand in hand to teach you to play elegant back-end interface 

MySQL 5.7 vs 8.0, You choose the one ? Net friend : I'm going to stay where I am ~


 Last , I recommend you an interesting and interesting official account : The guy who wrote the code ,7 Old programmers teach you to write bug, reply   interview | resources   Send you a complete set of Development Notes   There's a surprise 

版权声明
本文为[osc_5h77wdgp]所创,转载请带上原文链接,感谢

Scroll to Top