基于Redis的incr、发布订阅防并发和setnx、轮询防并发的理解

最新推荐文章于 2024-08-05 04:10:27 发布
最新推荐文章于 2024-08-05 04:10:27 发布
阅读量2.4k 收藏 1
点赞数
分类专栏： 分布式锁 文章标签： incr setnx redis 发布订阅 防并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39471249/article/details/79313224
版权

先上代码：
1、incr、发布订阅防并发

package com.xxx.epps.sfeicuss.common.anticoncurrency;

import com.xxx.epps.sfeicuss.common.enums.ResponseCode;
import com.xxx.epps.sfeicuss.common.exception.AppException;
import com.xxx.epps.sfeicuss.common.util.RedisClientUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

/**
 * 〈一句话功能简述〉<br>
 * 〈功能详细描述〉
 *
 * @author wangzha
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Service
public class PublishAndSubscribe {

    private static final Logger LOGGER = LoggerFactory.getLogger(PublishAndSubscribe.class);

    /**
     * 频道key
     */
    private static final String PUBANDSUB_KEY = "PUBANDSUB_KEY_";

    /**
     * 结果key
     */
    private static final String PUBANDSUB_RES_KEY = "PUB_RES_KEY_";

    /**
     * 发布成功
     */
    private static final String MSG_TRUE = "true";

    /**
     * 发布失败
     */
    private static final String MSG_FALSE = "false";

    /**
     * 默认重试次数
     */
    private static final int RETRY_TIME = 3;

    /**
     * 线程全局变量,用于统计重试次数
     */
    private ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return 1;
        }
    };

    /**
     * 入口
     *
     * @param key
     * @param clazz
     * @param retryTime
     * @param callBack
     * @param <T>
     * @return
     */
    public <T> T execute(String key, Class<T> clazz, int retryTime, CallBack callBack) {
        T result;
        String pasKey = PUBANDSUB_KEY + key;
        String pasResKey = PUBANDSUB_RES_KEY + key;
        if (retryTime < 1) {
            //重试次数不合法,默认为3
            retryTime = RETRY_TIME;
        }
        //抢占入口
        long incr = RedisClientUtils.incr(pasKey);
        LOGGER.debug("抢占到资源");
        boolean flag;
        if (incr == 1) {
            String msg = MSG_FALSE;
            //处理业务逻辑
            try {
                result = callBack.process();
                flag = callBack.handlerIsSuccessOrNot(result);
                LOGGER.debug("业务结果:{}", flag);
            } catch (Exception e) {
                LOGGER.error("回调业务处理异常", e);
                throw new AppException("回调业务处理异常", ResponseCode.ERROR.getCode());
            }
            if (flag) {
                //业务处理成功,则推送缓存,且发布
                RedisClientUtils.putBeanObj(pasResKey, result);
                msg = MSG_TRUE;
            }
            RedisClientUtils.del(pasKey);
            RedisClientUtils.publish(pasKey, msg);
            return result;
        } else {
            String subMsg = RedisClientUtils.subscribe(pasKey);
            LOGGER.debug("subMsg", subMsg);
            if (MSG_TRUE.equals(subMsg)) {
                result = RedisClientUtils.getBeanObj(pasResKey, clazz);
                LOGGER.debug("收到订阅消息:{}", result);
                return callBack.handlerResult(result);
            } else {
                //重试
                while (true) {
                    int time = threadLocal.get();
                    if (time < retryTime) {
                        time++;
                        return execute(key, clazz, retryTime, callBack);
                    } else {
                        throw new AppException("超过重试次数");
                    }
                }
            }
        }
    }
}

package com.xxx.epps.sfeicuss.common.anticoncurrency;

/**
 * 〈一句话功能简述〉<br>
 * 〈功能详细描述〉
 *
 * @author wangzha
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public interface CallBack{
    <T> T process();

    <T> boolean handlerIsSuccessOrNot(T result);

    <T> T handlerResult(T result);
}

2、setnx、轮询防并发

package com.xxx.epps.sfeicuss.common.anticoncurrency;

import com.xxx.epps.sfeicuss.common.enums.ResponseCode;
import com.xxx.epps.sfeicuss.common.exception.AppException;
import com.xxx.epps.sfeicuss.common.util.RedisClientUtils;
import com.xxx.epps.sfeicuss.common.util.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 〈一句话功能简述〉<br>
 * 〈功能详细描述〉
 *
 * @author wangzha
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public class OneAfterOne {


    private static final Logger LOGGER = LoggerFactory.getLogger(OneAfterOne.class);

    /**
     * 锁key
     */
    private static final String OAO_LOCK_KEY = "OAO_LOCK_KEY_";

    /**
     *
     */
    private static final String OAO_LOCK_VALUE = "OAO_LOCK_VALUE";

    /**
     * 返回结果缓存key
     */
    private static final String OAO_RESULT_KEY = "OAO_RESULT_KEY_";

    /**
     * 轮询超时时间
     */
    private static final long TIME_OUT = 2000;

    /**
     * 锁超时时间
     */
    private static final long LOCK_KEY_TIME_OUT = 5;

    /**
     * 重试次数
     */
    private static final int RETRY_TIME = 3;

    /**
     * 线程全局变量,用于统计重试次数
     */
    private ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return 1;
        }
    };

    /**
     * 订制入口
     *
     * @param cachekey
     * @param timeOut
     * @param lockTimeOut
     * @param retryTime
     * @param callBack
     * @return
     */
    public String execute(String cachekey, long timeOut, long lockTimeOut, int retryTime, OneAfterOneCallBack callBack) {
        String result;
        /************缓存key初始化**************/
        //构造锁key
        String key = OAO_LOCK_KEY + cachekey;
        //设置轮询超时时间
        if (timeOut <= 0) {
            timeOut = TIME_OUT;
        }
        //设置锁超时时间
        if (lockTimeOut <= 0) {
            lockTimeOut = LOCK_KEY_TIME_OUT;
        }

        /****************并发处理****************/
        try {
            //获取锁
            boolean lock = RedisClientUtils.setnx(key, OAO_LOCK_VALUE, lockTimeOut);
            //构造结果key
            String resultKey = OAO_RESULT_KEY + cachekey;
            if (lock) {
                //获取锁,回调业务处理
                result = callBack.process();
                //判断业务是否成功,成功将结果放入缓存,否则回调异常处理
                boolean resultFlag = callBack.handlerIsSuccessOrNot(result);
                if (resultFlag) {
                    RedisClientUtils.setExpire(resultKey, result, 1);
                } else {
                    callBack.handlerSerivceException(result);
                }
                RedisClientUtils.del(key);
                return result;
            } else {
                int time = threadLocal.get();
                while (true) {
                    //轮询
                    result = this.pollingReuslt(resultKey, timeOut);
                    LOGGER.info("轮询获取结果:{}", result);
                    if (StringUtils.isNotEmpty(result)) {
                        //处理轮询结果
                        return callBack.handlerResult(result);
                    }
                    if (time > retryTime) {
                        //超过重试次数
                        throw new AppException("超过重试次数");
                    } else {
                        time++;
                        //轮训次数已满,尝试重新获取锁
                        return execute(cachekey, timeOut, lockTimeOut, retryTime, callBack);
                    }
                }
            }
        } catch (AppException e) {
            throw new AppException(ResponseCode.ERROR.getCode(), "OneAfterOne异常");
        }

    }

    /**
     * 通用入口
     *
     * @param cachekey
     * @param callBack
     * @return
     */
    public String execute(String cachekey, OneAfterOneCallBack callBack) {
        return execute(cachekey, TIME_OUT, LOCK_KEY_TIME_OUT, RETRY_TIME, callBack);
    }

    /**
     * 轮询等待结果
     *
     * @param resultKey
     * @return
     */
    private String pollingReuslt(String resultKey, long timeOut) {
        long startTime = System.currentTimeMillis();
        while (true) {
            try {
                //休眠
                Thread.sleep(50);
            } catch (InterruptedException e) {
                LOGGER.error("系统异常", e);
                throw new AppException("系统异常", ResponseCode.ERROR.getCode());
            }
            //尝试获取上一笔的处理结果
            String result = RedisClientUtils.get(resultKey);
            if (!(StringUtils.isEmpty(result) && (System.currentTimeMillis() - startTime) / 1000 < timeOut)) {
                return result;
            }
        }
    }
}

package com.xxx.epps.sfeicuss.common.anticoncurrency;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.xxx.epps.sfeicuss.common.enums.ResponseCode;
import com.xxx.epps.sfeicuss.common.lang.ObjectResponse;

import java.util.Map;

/**
 * 〈一句话功能简述〉<br>
 * 〈功能详细描述〉
 *
 * @author wangzha
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
public abstract class OneAfterOneCallBack {

    /**
     * 业务需实现的防并发方法
     *
     * @return
     */
    protected abstract String process();

    /**
     * 判断第一笔是否处理成功
     * 默认0000为成功,可以根据业务场景重写
     */
    protected boolean handlerIsSuccessOrNot(String result) {
        boolean flag = false;
        ObjectResponse<Map<String, Object>> response = JSON.parseObject(result, new TypeReference<ObjectResponse<Map<String, Object>>>() {
        });
        String reponseCode = response.getResponseCode();
        if (ResponseCode.SUCCESS.getCode().equals(reponseCode)) {
            flag = true;
        }
        return flag;
    }

    /**
     * 轮询到的结果,处理.业务可以根据需要重写
     *
     * @return
     */
    protected String handlerResult(String result) {
        return result;
    }

    /**
     * 业务异常情况
     *
     * @return
     */
    protected String handlerSerivceException(String result) {
        return result;
    }
}

先说明：笔者对于redis的中层、底层还没有开始阅读理解。这里先表达运用层的理解。

1、incr和setnx都能实现锁的功能
2、incr额外提供计数功能，老大一直不明白我为啥要用incr实现这个锁，我自己也不清楚。后面对redis开撸之后可能会理解。
3、incr没有超时时间的概念，发布订阅也不存在。incr只能删key，发布订阅只能退订频道。发布是多链接，订阅是单链接。
4、第一种方案有一个bug,如果第一个线程发布意外失败，其余等待线程全部阻塞在subscribe，那么其余线程全部会死掉。等待的线程需要时间控制他们。但是还没想到什么方案来对付这种情况。
5、对于发布订阅来说，20笔请求进来，19笔请求必须等待第一笔处理结果publish后，自己subscribe后才能进行其他操作。也就是说如果业务5S超时，那么5秒内堆积的线程都要等第一笔处理结束。大量并发的情况下就会出现拥堵。
对于这一点，第二种防并发方案可以通过，轮询的超时时间和锁的超时时间来避免，即在业务5s的处理过程中，假如等待线程如果轮询了2s，我们可以选择不让他们接着等待，而是自己再去发起业务请求。
6、注意轮询时间最好不要小于锁key的时间。可以选择相等。key的时间和业务处理的时间需要衡量对比。以及上游系统调用本系统的超时时间结合起来 来决定是否必要重试，以及重试次数。
7、注意轮询拿不到结果如果选择重试一定要设置重试次数。否则可能会无限轮询。

中低层了解的太少不敢妄言，希望大家能指点指点，说错的地方谅解。

对于轮询的又一种编写：

/**
 * 〈一句话功能简述〉<br>
 * 〈功能详细描述〉
 *
 * @author wangzha
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Component
public class OneAfterOne<T extends GenericResponse> {

    private static final Logger LOGGER = LoggerFactory.getLogger(OneAfterOne.class);

    /**
     * 锁key
     */
    private static final String BIZTYPE_DEFAULT = "DEFAULT_";
    /**
     * 锁key
     */
    private static final String ONEAFTERONE_LOCK_KEY = "ONEAFTERONE_LOCK_";

    /**
     * 锁value
     */
    private static final String ONEAFTERONE_LOCK_VALUE = "ONEAFTERONE_LOCK_VALUE";

    /**
     * 返回结果缓存key
     */
    private static final String ONEAFTERONE_RESULT_FLAG_KEY = "ONEAFTERONE_RESULT_FLAG_";

    /**
     * 业务处理有结果标记
     */
    private static final String ONEAFTERONE_OK = "OK";

    /**
     * 服务超时时间
     */
    private static final String SERVICE_TIME_OUT = "serviceTimeOut";

    /**
     * 轮询间隔时间
     */
    private static final String POLLING_INTERVAL = "pollingInterval";

    /**
     * 功能描述: 防止一段时间内,相同的入参多比重复请求<br>
     * 〈功能详细描述〉 1、多笔请求进来,用setnx去获取锁. 2、拿到锁的进行业务处理回调,并将完整的业务处理结果返回.
     * 3、组件OAO将第一笔处理的是否成功的标记(OK)放入结果缓存.(此处只要业务系统不抛异常,都是为业务处理有结果) 回调缓存处理
     * 4、未拿到锁的请求,进行轮询获取结果缓存来判断第一笔是否处理有结果,如果轮询有结果,回调获取缓存;无结果,抛出业务处理异常
     * <p>
     * 注意：serviceTimeOut与rsf接口超时时间一致,标记缓存时间和锁的缓存时间一致
     *
     * @param cachekey        业务缓存key
     * @param serviceTimeOut  服务超时时间
     * @param pollingInterval 轮询间隔时间
     * @param callBack        回调
     * @return T
     * @see [相关类/方法]（可选）
     * @since [产品/模块版本] （可选）
     */
    @SuppressWarnings("unchecked")
    public T execute(String cachekey, long serviceTimeOut, long pollingInterval, OneAfterOneCallBack<T> callBack) {
        LOGGER.debug("uniqueKeys:{},进入oneAfterOne组件,服务超时时间:{},轮询间隔时间:{}", cachekey, serviceTimeOut, pollingInterval);
        T result;
        String key = ONEAFTERONE_LOCK_KEY + cachekey;
        // 获取锁
        boolean lock = RedisClientUtils.setnx(key, ONEAFTERONE_LOCK_VALUE, serviceTimeOut / 1000);
        // 构造结果标记key
        String resultKey = ONEAFTERONE_RESULT_FLAG_KEY + cachekey;
        if (lock) {
            // 获取锁,回调业务处理
            try {
                result = callBack.process();
            } catch (AppException e) {
                LOGGER.error("该笔业务处理抛出异常" + key, e);
                GenericResponse response = new GenericResponse();
                response.response(e.getErrorCode(), e.getMessage());
                result = (T) response;
            } catch (RuntimeException e) {
                LOGGER.error("该笔业务处理抛出异常" + key, e);
                GenericResponse response = new GenericResponse(ResponseCode.ERROR);
                result = (T) response;
            }
            // 缓存结果
            callBack.cache(cachekey, result);
            // 回调业务处理有结果,将OK标记放入缓存
            RedisClientUtils.setExpire(resultKey, ONEAFTERONE_OK, 1);
            return result;
        } else {
            // 轮询
            String pollingResult;
            long startTime = System.currentTimeMillis();
            LOGGER.info("{},该笔进入轮训", cachekey);
            while (true) {
                LOGGER.debug("{}该笔进入轮训", cachekey);
                // 尝试获取上一笔的处理结果
                pollingResult = RedisClientUtils.get(resultKey);
                // 轮询结果不为空或者超出轮询时间,跳出循环,否则继续循环
                if (pollingResult != null || (System.currentTimeMillis() - startTime) > serviceTimeOut) {
                    break;
                }
                // 休眠
                sleep(pollingInterval);
            }
            LOGGER.info("{},该笔退出轮训,轮询获取结果:{}", cachekey, pollingResult);
            if (ONEAFTERONE_OK.equals(pollingResult)) {
                // 处理轮询结果
                result = callBack.getCache();
                if (result == null) {
                    LOGGER.error(ResponseCode.ERROR.getCode(), "轮训到OK，无结果明细！");
                    throw new AppException(ResponseCode.ERROR);
                } else {
                    return callBack.getCache();
                }
            } else if (StringUtils.isEmpty(pollingResult)) {
                throw new AppException(ResponseCode.POLLING_TIME_OUT);
            } else {
                throw new AppException(ResponseCode.ERROR);
            }
        }
    }

    /**
     * 通用入口
     *
     * @param prefix
     * @param cachekey
     * @param callBack
     * @param <T>
     * @return
     */
    public T execute(String bizType, String[] uniqueKeys, OneAfterOneCallBack<T> callBack) {
        Assert.notEmpty(uniqueKeys, "业务入参用于拼装唯一key，不可以为空！");
        String cachekey = bizType + StringUtils.join(Symbols.UNDERLINE, uniqueKeys);
        return execute(cachekey, getServiceTimeOut(bizType), getPoolingInterval(bizType), callBack);
    }

    /**
     * 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param string
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    private long getServiceTimeOut(String bizType) {
        long serviceTimeOut = SCMServiceCfg.getNode(bizType + SERVICE_TIME_OUT);
        return serviceTimeOut > 0 ? serviceTimeOut : SCMServiceCfg.getNode(BIZTYPE_DEFAULT + SERVICE_TIME_OUT);
    }

    /**
     * 功能描述: <br>
     * 〈功能详细描述〉
     *
     * @param string
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    private long getPoolingInterval(String bizType) {
        long poolingInterval = SCMServiceCfg.getNode(bizType + POLLING_INTERVAL);
        return poolingInterval > 0 ? poolingInterval : SCMServiceCfg.getNode(BIZTYPE_DEFAULT + POLLING_INTERVAL);
    }

    /**
     * 休眠
     *
     * @param pollingInterval
     */
    private void sleep(long pollingInterval) {
        try {
            // 休眠
            Thread.sleep(pollingInterval);
        } catch (Exception e) {
            LOGGER.error("系统异常", e);
        }
    }

//    public static void main(String[] args) {
//        long startTime = System.currentTimeMillis();
//        while (true) {
//            long time = System.currentTimeMillis() - startTime;
//            long time2 = (System.currentTimeMillis() - startTime)/1000;
//            System.out.println("time:" + time);
//            System.out.println("time2:" + time2);
//            System.out.println("time3:" + System.currentTimeMillis());
//            if (time / 1000 > 5000) {
//                System.out.println("in");
//                break;
//            }
//            try {
//                // 休眠
//                Thread.sleep(50);
//            } catch (Exception e) {
//                LOGGER.error("系统异常", e);
//            }
//        }
//        System.out.println("out");
//    }
}
九十三大人
关注
专栏目录
使用Redis原子计数器incr防止并发请求
DpJulia的博客
10-14 410
在上面的示例代码中，我们使用了Python的threading模块来创建多个并发请求，并在每个请求中调用process_request函数来处理递增操作。Redis的原子计数器incr命令可以对存储在Redis中的一个键进行原子性的递增操作。接下来，我们可以编写一个Python函数来处理并发请求，并使用Redis的原子计数器incr来确保递增操作的原子性。通过使用Redis的原子计数器incr以及全局锁，我们可以确保多个并发请求能够安全地对计数器进行递增操作，避免了数据不一致的问题。
redis的五种数据类型
热门推荐
学Java，找哪吒
05-15 5万+
（1）Redis（Remote Dictionary Server 远程字段服务）是一个开源的使用ANSI C语言编写、支持网络、科技与内存亦可持久化的日志型、key-value数据库，并提供多种语言的API。（2）Redis是一个key-value存储系统，它支持存储的value类型相对更多，包括string、list、set、zset（sorted set --有序集合）和hash。这些数据结构都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。
Redis发布与订阅
身体，灵魂，技术。总要有一个在前进
03-28 879
什么是发布与订阅 Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。 Redis 客户端可以订阅任意数量的频道。 下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系： 当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端 Redis的发布与订阅 订阅 ..
Redis怎么实现轮训
最新发布
weixin_40229368的博客
08-05 29
Redis怎么实现轮询 引言 轮询是一种常见的分配或调度算法，通常用于负载均衡和资源分配等场景。在分布式系统中，如何高效地实现轮询是一项重要的挑战。Redis 作为一种高性能的键值存储系统，因其高效的数据访问和良好的支持单机模式和分布式模式而被广泛使用。在本文章中，我们将深入探讨如何使用 Redis 实现轮询，并通过实际的...
Redis incr解决并发问题
chen_lay的博客
08-15 1万+
项目背景： 1、新增问题件工单，工单中有工单编码字段，工单编码字段的规则为 “WT”+yyyyMMdd+0000001。 2、每天的工单生成量是30W，所以会存在并发问题 解决思路： 1、首先乐观的认为redis不会宕机，对应的缓存不会被清除（除非人为操作，人为操作会有独立的补救办法） 2、将工单编码存到缓存中（redis）,其值只存“WT”+yyyyMMdd后面的数字部分； ...
redis 如何实现发布订阅？redis事务详解
m0_60274784的博客
12-04 189
Redis 发布订阅（pub/sub）是一种消息通信模式： 发送者发送消息（pub）订阅者接收消息（sub） 实例： 准备工作：一台主机的两个终端 创建一个订阅频道channel 在另一个终端，发布两个消息 此时会发现，订阅者终端会显示发布的信息 发布订阅拿下！ redis事务 a 作用：串联多个命令防止别的命令插队 b 特征：1 事务是一个原子操作：原子性（Atomicity）（不可分割性） 要么完成，要么不完成，不会存在中间态 2 事务是一...
【并发】9、借助redis 实现生产消费，消息订阅发布模式队列
weixin_30672019的博客
06-12 215
这个就是一个消息可以被多次消费的范例了 其实这个实现的方式可以参考我之前的设计模式，观察者模式 https://www.cnblogs.com/cutter-point/p/5249780.html 不过有一点需要注意一下啊，这个消息发布的时候，好像是不支持字节数据的，里面好像会对字节进行转换，这样的结果就是导致我最后无法吧相应的字节转换成我之前序列化的对象 不知道是不是Object...
Redis事务和并发控制
Tyshawn的博客
03-04 1886
什么是Redis事务? Redis事务不保证原子性, 即事务中的某个命令执行失败, 事务不会回滚, 且后续命令会继续执行. 这样一来, Redis事务的功能就和脚本差不多, 都是将命令打包, Redis事务能做的事, 脚本也能做, 而且脚本速度更快. (1) Redis事务相关的命令 MULTI 开启一个事务, 后续的命令都会添加到一个队列中, 等待EXEC命令. EXEC 触发并执行事务中的所...
Redis全面解析二：redis高可用高并发集群方案
Mr_lisj的博客
05-02 2049
前言 Redis 缓存作为使用最多的缓存工具被各大厂商争相使用。通常我们会使用单体的 Redis 应用作为缓存服务，然而我们日常在对于redis的使用中，经常会遇到一些问题： 高可用问题，如何保证redis的持续高可用性。 容量问题，单实例redis内存无法无限扩充，达到32G后就进入了64位世界，性能下降。 并发性能问题，redis号称单实例10万并发，但也是有尽头的。 如果只使用一个r...
redis watch使用场景_redis事务、并发及应用场景
weixin_39573598的博客
12-19 309
事务概念事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。redis事务是一组命令的集合。多组命令进入到等待执行的事务队列中，执行exec命令告诉redis将等待执行的事务队列中的所有命令，按顺序执行，返回值就是这些命令组成的列表。Redis 事务可以一次...
2023年再不会Redis，就要被淘汰了
学Java，找哪吒
03-06 2万+
Redis实战系列，打造精品专栏。
Redis(九)：并发问题
weixin_43844995的博客
03-20 1210
上一篇介绍了 Redis 的内存管理。这节开始介绍 Redis 并发方面的问题。Redis 的单个命令是原子的，但是一个业务操作可能包含多条命令，比如以下场景：客户端查询值，并递增，在高并发场景下就可能出现并发问题，导致数据不一致。为了保证并发访问的正确性，Redis 提供了三种方法，原子操作、分布式锁、事务。本文介绍了 Redis 应对并发问题的三种方案，Redis 中的单条命令都是原子操作，而且还有 INCR/DECR 来应对简单的场景。
【Redis高并发经典问题】
liumeina_study的博客
05-25 535
本文主要总结了Redis实战中常见的高并发问题：缓存穿透，缓存击穿，缓存雪崩，数据库缓存双写不一致，数据并发竞争问题
redis实现分布式锁的几种方式
程序猿踩坑集锦
12-08 2496
1. redis加锁分类 redis能用的的加锁命令分表是INCR、SETNX、SET 2. 第一种锁命令INCR 这种加锁的思路是， key 不存在，那么 key 的值会先被初始化为 0 ，然后再执行 INCR 操作进行加一。 然后其它用户在执行 INCR 操作进行加一时，如果返回的数大于 1 ，说明这个锁正在被使用当中。 1、 客户端A请求服务器获取key的值为1表示获取了锁 2、 客户端B也去请求服务器获取key的值为2表示获取锁失败 3、 客户端A执行代码完成，删除锁 4、 客户端B.
用redis实现支持优先级的消息队列
weixin_34033624的博客
05-09 107
http://www.cnblogs.com/tianqiq/p/4309791.htmlhttp://www.cnblogs.com/it-cen/p/4312098.htmlhttp://www.cnblogs.com/alexkn/p/4314143.htmlhttp://www.cnblogs.com/vchenpeng/p/4325256.html360导航_新一代安全上网导航http:...
如何应对面试？我对Redis知识点的总结（一）
Daniel的博客
05-30 416
点击上方“后端开发技术”，选择“设为星标”优质文章和资源，及时送达为什么要做这个总结如今Redis已经像MySQL一样，成为了一名后端开发攻城狮必会的技术。面试中更是被频频问到，甚至占...
SETNX分布锁详解
qq_47288175的博客
10-21 2万+
SETNX作为分布式锁详解
redis类型讲解[string, list, set, sorted set, hash]
我是guyue，guyue就是我O(∩_∩)O
12-26 3172
Keys redis本质上一个key-value db，所以我们首先来看看他的key. 首先key也是字符串类型，但是key中不能包括边界字符；由于key不是binary safe的字符串，所以像”my key”和”mykey\n”这样包含空格和换行的key是不允许的 注： 顺便说一下在redis内部并不限制使用binary字符，这是redis协议限制的。”\r\n”在协议格式中会作为特殊字符。 redis 1.2以后的协议中部分命令已经开始使用新的协议格式了(比如MSET)。总之目前还是把包含边
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值