前言

解决问题：多个进程多台机器，对一个数据进行的操作的互斥。比如，下订单和扣库存的操作，这两个操作必须连贯，一个线程执行完这两个操作后，下面一个线程才可以介入执行，如果同时并发执行，极大可能会出现“多卖”的现象。

解决方法：

1、sql 层面上：

可以使用 SELECT FOR UPDATE 行级锁来实现。

2、代码层面上：

synchronized 关键字，给方法加一把锁，这样可以解决并发问题，但是排队执行的速度很慢，高并发情况下不宜这么干。
Redis 分布式锁，主要利用SETNX 命令和 GETSET命令。解决高并发。

以上三种方法都可以解决问题，今天要讨论的是第三种 —— Redis 分布式锁

Redis分布式锁基础指令

SETNX

语法：

SETNX key value

将key设置值为value，如果key不存在，这种情况下等同SET命令。当key存在时，什么也不做。SETNX是”SET if Not eXists”的简写。

返回值：

1 如果key被设置了
0 如果key没有被设置

例子：

redis> SETNX mykey "Hello"
(integer) 1
redis> SETNX mykey "World"
(integer) 0
redis> GET mykey
"Hello"
redis>

用途：可以用来枷锁。比如给商品id加锁。

详细命令说明请参考： SETNX key value

GETSET

语法：

GETSET key value

自动将key对应到value并且返回原来key对应的value。如果key存在但是对应的value不是字符串，就返回错误。

这个解释有点拗口，其实可以拆开看，先GET，最后再SET，返回之前的旧值，如果之前Key不存在将返回nil。

例子：

redis> INCR mycounter
(integer) 1
redis> GETSET mycounter "0"
"1"
redis> GET mycounter
"0"
redis>

用途：解决死锁。原理即是将原来的锁替换成新锁。

详细命令说明请参考： GETSET key value

Redis分布式锁使用

如下工具类RedisLock：


import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

/**
 * Redis分布式锁
 */
@Component
@Slf4j
public class RedisLock {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 加锁
     * @param key
     * @param value 当前时间+超时时间
     * @return
     */
    public boolean lock(String key, String value) {

        if(redisTemplate.opsForValue().setIfAbsent(key, value)) {//相当于SETNX指令，setIfAbsent方法设置了返回true,没有设置返回false
            return true;
        }
        //假设currentValue=A   接下来并发进来的两个线程的value都是B  其中一个线程拿到锁,除非从始至终所有都是在并发（实际上这中情况是不存在的），只要开始时有数据有先后顺序，则分布式锁就不会出现“多卖”的现象
        String currentValue = redisTemplate.opsForValue().get(key);
        //如果锁过期  解决死锁
        if (!StringUtils.isEmpty(currentValue)
                && Long.parseLong(currentValue) < System.currentTimeMillis()) {
            //获取上一个锁的时间，锁过期后，GETSET将原来的锁替换成新锁
            String oldValue = redisTemplate.opsForValue().getAndSet(key, value);
            if (!StringUtils.isEmpty(oldValue) && oldValue.equals(currentValue)) {
                return true;
            }
        }

        return false;//拿到锁的就有执行权力，拿不到的只有重新再来，重新再来只得是让用户手动继续抢单
    }

    /**
     * 解锁
     * @param key
     * @param value
     */
    public void unlock(String key, String value) {
        try {
            String currentValue = redisTemplate.opsForValue().get(key);
            if (!StringUtils.isEmpty(currentValue) && currentValue.equals(value)) {
                redisTemplate.opsForValue().getOperations().delete(key);
            }
        }catch (Exception e) {
            log.error("【redis分布式锁】解锁异常, {}", e);
        }
    }

}

由源码可以看见，setIfAbsent 来实现加锁功能，如果一些网络或是io等原因抛异常造成了死锁，则当当前锁操作过期时间后，getAndSet 会用新锁替换掉原来的旧锁，从而实现解决死锁问题。

运用：


    private static final int TIMEOUT = 10 * 1000; //超时时间 10s

    @Autowired
    private RedisLock redisLock;

    public void orderProductMockDiffUser(String productId)
    {
        //加锁
        long time = System.currentTimeMillis() + TIMEOUT ;
        if(!redisLock.lock(productId,String.valueOf(time))){ //如果返回
            throw SellException(101,"并发量太多了，换个姿势再试试！"); 
        }

        /*****如果被锁，则下面的代码都不会被执行*******/

        //1.查询该商品库存，为0则活动结束。
        int stockNum = stock.get(productId);
        if(stockNum == 0) {
            throw new SellException(100,"活动结束");
        }else {
            //2.下单(模拟不同用户openid不同)
            orders.put(KeyUtil.genUniqueKey(),productId);
            //3.减库存
            stockNum =stockNum-1;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            stock.put(productId,stockNum);
        }

        //解锁
        redisLock.unlock(productId,String.valueOf(time));
    }

Redis分布式锁原理及实现

前言

Redis分布式锁基础指令

SETNX

GETSET

Redis分布式锁使用

猜你喜欢