How does redis solve inventory concurrency issues and achieve quantity control?

Redis is a single process and blocking type. It can only process one request at the same time, and subsequent requests need to be queued and waited.

Advantages: Because it is a single process, there is no need to deal with concurrency issues, reducing system complexity

Disadvantages: Not suitable for caching large-size objects (more than 100kb)

Reason: Due to Redis only uses a single core, while Memcached can use multiple cores, so on average Redis has higher performance than Memcached when storing small data on each core.

For data of more than 100k, the performance of Memcached is higher than that of Redis. Although Redis has also optimized the performance of storing big data, it is still slightly inferior to Memcached.

memcache is multi-process and non-blocking. If it is only used as a cache, memcache is more suitable.

1. Command

exists Check whether the key key already exists in redis, for example exists mycounter

set Set initialize a key value such as set mycounter 99

get Get a key value such as getmycounter

incr increases by 1, for example incrmycounter //The output result is 100

incrby specifies the increase value, for example incrbymycounter 2 //The output result is 102

specifies the decrease value, for example incrbymycounter -2 //The output result is 100

setnx When the value does not exist, the value is set successfully. For example, setnxmycounter 99 //The output result is 0, which means the setting failed and already exists in redis.

setnx key1 12 //The output result is 1 , indicating that the setting is successful and has not existed in redis before.

expire Set the life cycle of a key, such as expire mycounter 30 //Set to 30 seconds validity period

ttl Get the key expiration time, such as ttlmycounter //Output It is 13, which means there are 13 seconds left. If it returns -1, it means it will never expire and will always exist in the redis cache, unless there is insufficient memory.

//If it returns -2, it means it has expired and redis has no such The key value can be verified with exists, and 0 is returned, which means it does not exist

2. Common scenarios

Due to the rush to buy the product, the quantity cannot be controlled, causing the inventory to exceed the limit, resulting in insufficient costs. (For example: The inventory is 1,000, but the user successfully purchased 2,000 items, and the inventory is insufficient.)

The lottery limit is limited, I didn’t control it, and I spent too much money

Grab red envelopes

3. Flowchart and code

Plan 1 Flowchart:

Plan 2 Flowchart:

//方案1代码,测试坏境TP5
public function redisCountV1(){
    Log::record("测试版本1并发开始", Log::INFO);
    $redis = new Redis();
    //总库存数量
    $amountLimit = 100;
    //redis存储库存键名
    $keyName = "mycounter_v6";
    //假设每次消耗库存数为1
    $incrAmount = 1;
    //判断redis中是否 存在该值，如果不存在，则用set设置（问题是如果出现并发，两个或多个用户同时访问，会导致库存重新设置）
    if(!$redis->exists($keyName)){
        $redis->set($keyName, 95);
    }
    //从redis中取出当前库存数
    $currAmount = $redis->get($keyName);
    //如果当前库存数+增长的库存数>总库存，直接返回
    if($currAmount + $incrAmount > $amountLimit) {
        file_put_contents("/Users/han/Documents/www/cs/testv1.log", "bad luck \n", FILE_APPEND);
        Log::record("bad luck", Log::INFO);
        return false;
    }
    //缓存库存数量增加
    $redis->incrby($keyName, $incrAmount);
    file_put_contents("/Users/han/Documents/www/cs/testv1.log", "good luck \n", FILE_APPEND);
    Log::record("good luck", Log::INFO);
}

//测试方式：ab  -c 100 -n 200 http://www.fenleduo.com:8080/V7/Test/redisCountV1

//方案2代码，测试坏境TP5
public function redisCountV2(){
    Log::record("测试版本2并发开始", Log::INFO);
    $redis = new Redis();
    //总库存数量
    $amountLimit = 100;
    //redis存储库存键名
    $keyName = "mycounter_v12";
    //假设每次消耗库存数为1
    $incrAmount = 1;
    //判断redis中是否 存在该值，如果不存在，则用setnx设置（注：如果出现并发，两个或多个用户同时访问，不会导致库存重新设置）
    if(!$redis->exists($keyName)){
        //setnx 如果不存在该值，则设置，如果存在则不会设置
        $redis->setnx($keyName, 95);
    }
    //从redis中取出当前库存数
    $currAmount = $redis->get($keyName);
    //如果当前库存数+增长的库存数>总库存，直接返回
    if($redis->incrby($keyName, $incrAmount) > $amountLimit) {
        file_put_contents("/Users/han/Documents/www/cs/testv2.log", "bad luck \n",FILE_APPEND);
        Log::record("bad luck", Log::INFO);
        return false;
    }
    file_put_contents("/Users/han/Documents/www/cs/testv2.log", "good luck \n",FILE_APPEND);
    Log::record("good luck", Log::INFO);
}
//测试方式：ab  -c 100 -n 200 http://www.fenleduo.com:8080/V7/Test/redisCountV2

The above is the detailed content of How does redis solve inventory concurrency issues and achieve quantity control?. For more information, please follow other related articles on the PHP Chinese website!