使用redis做无锁秒杀

最新推荐文章于 2024-06-03 19:58:35 发布
最新推荐文章于 2024-06-03 19:58:35 发布
阅读量357 收藏
点赞数
分类专栏： Springboot 工具类 文章标签： redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45167029/article/details/120461831
版权

使用redis做秒杀无需锁

简单说明下

使用Redis中hsah中的 hincrby 方法 k1=商品Id vk=skuId vv=库存数量 该操作有返回值 自增或自减后的 结果进行判断

hash解构

​ -k: 商品id

​ -k:商品sku1 ID -v:对应库存100

​ -k:商品sku2 ID -v:对应库存20

​ -k:商品sku3 ID -v:对应库存30

​ -k:商品sku4 ID -v:对应库存40

HINCRBY 1 1 -1 redis操作命令 自减1

“99” 返回结果 “99”

原理就是这样

这里使用的是Jedis

		<!-- Redis-Jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>

Jedis工具类 这是一个大哥写的,但是当时手贱我删掉了,蛮好用的

  1. redis配置文件 没有的参数就不要乱填写 否则项目正常启动但是 会获取不到资源

    # redis 配置
redis:
  # 地址
  host: 127.0.0.1
  # 端口，默认为6379
  port: 6379
  # 数据库索引
  database: 0
  # 密码(没有就不要填写了)
  password:
  # 连接超时时间
  timeout: 10000
  pool:
    # 连接池中的最小空闲连接
    min-idle: 0
    # 连接池中的最大空闲连接
    max-idle: 8
    # 连接池的最大数据库连接数
    max-active: 200
    # #连接池最大阻塞等待时间（使用负值表示没有限制）
    max-wait: -1

  2. Jedis配置,项目注入JedisPool池

    package com.dog.common.config.jedis;

import com.dog.common.utils.SUtils;
import lombok.Data;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Jedis配置，项目启动注入JedisPool
 * http://www.cnblogs.com/GodHeng/p/9301330.html
 *
 * @author dolyw.com
 * @date 2018/9/5 10:35
 */
@Configuration
@EnableAutoConfiguration
@ConfigurationProperties(prefix = "redis")
@Data
public class JedisConfig {

    /**
     * logger
     */
    private static final Logger logger = LoggerFactory.getLogger(JedisConfig.class);
    /**
     * 地址
     **/
    private String host;
    /**
     * 端口
     **/
    private int port;
    /**
     * 密码
     **/
    private String password;

    /**
     * 连接超时时间
     **/
    private int timeout;

    /**
     * 数据库索引 ,默认是0
     **/
    private int database=0;

    @Value("${redis.pool.max-active}")
    private int maxActive;

    @Value("${redis.pool.max-wait}")
    private int maxWait;

    @Value("${redis.pool.max-idle}")
    private int maxIdle;

    @Value("${redis.pool.min-idle}")
    private int minIdle;

    @Bean
    public JedisPool redisPoolFactory() {
        try {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxIdle(maxIdle);
            jedisPoolConfig.setMaxWaitMillis(maxWait);
            jedisPoolConfig.setMaxTotal(maxActive);

            // 密码为空设置为null
            if (SUtils.isEmpty(password)) {
                password = null;
            }
            JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout, password,database);
            logger.info("初始化Redis连接池JedisPool成功!地址: " + host + ":" + port +":"+"数据库索引"+database);
            return jedisPool;
        } catch (RuntimeException e) {
            logger.error("初始化Redis连接池JedisPool异常:" + e.getMessage());
        }
        return null;
    }
}

  3. JedisUtil

    package com.dog.common.utils;


import com.dog.common.constant.Constant;
import com.dog.common.exception.CustomException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.util.Set;

/**
 * redis工具类
 */
@Component
//@Slf4j
public class JedisUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext = null;
    public JedisUtil() {
    }

    /**
     * 获取redis实例
     * @return
     */
    public Jedis getJedis() {
        Jedis jedis = null;
        synchronized (Jedis.class) {
            try {
                jedis = getJedisPool().getResource();
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
        return jedis;
    }

    public JedisPool getJedisPool() {
        JedisPool jedisPool = null;
        if (jedisPool == null) {
            synchronized (JedisPool.class) {
                if (jedisPool == null) {
                    jedisPool = applicationContext.getBean(JedisPool.class);
                }
            }
        }
        return jedisPool;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if (JedisUtil.applicationContext == null) {
            JedisUtil.applicationContext = applicationContext; //初始化 spring applicationContext
        }
    }

    /**
     * 根据key查看是否存在
     *
     * @param key
     * @return
     */
    public boolean hasKey(String key) {
        Jedis jedis=null;
        try{
            jedis = getJedis();
            return jedis.exists(key);
        }catch (Exception e){
            //log.info("JedisUtil.hasKey异常："+e.getMessage());
            return false;
        }finally {
            disConnect(jedis);
        }
    }

    /**
     * 设置key -value 形式数据
     *
     * @param key
     * @param value
     * @return
     */
    public String set(String key, String value) {
        Jedis jedis=null;
        try{
            jedis = getJedis();
            return jedis.set(key, value);
        }catch (Exception e){
            //log.info("JedisUtil.set(String key, String value)异常："+e.getMessage());
            return null;
        }finally {
            disConnect(jedis);
        }

    }

    /**
     * 设置 一个过期时间
     *
     * @param key
     * @param value
     * @param timeOut 单位秒
     * @return
     */
    public String set(String key, String value, int timeOut) {
        Jedis jedis=null;
        try{
            jedis = getJedis();
            return jedis.setex(key, timeOut, value);
        }catch (Exception e){
            //log.info("JedisUtil.set(String key, String value, int timeOut)异常："+e.getMessage());
            return null;
        }finally {
            disConnect(jedis);
        }
    }

    /**
     * 根据key获取value
     *
     * @param key
     * @return
     */
    public String getByKey(String key) {
        Jedis jedis=null;
        try{
            jedis = getJedis();
            return jedis.get(key);
        }catch (Exception e){
            //log.info("JedisUtil.getByKey(String key)异常："+e.getMessage());
            return null;
        }finally {
            disConnect(jedis);
        }
    }

    /**
     * 根据通配符获取所有匹配的key
     * @param pattern
     * @return
     */
    public Set<String> getKesByPattern(String pattern) {
        Jedis jedis=null;
        try{
            jedis = getJedis();
            return jedis.keys(pattern);
        }catch (Exception e){
            //log.info("JedisUtil.getKesByPattern(String pattern)异常："+e.getMessage());
            return null;
        }finally {
            disConnect(jedis);
        }
    }

    /**
     * 根据key删除
     * @param key
     */
    public void delByKey(String key) {
        Jedis jedis=null;
        try{
            jedis = getJedis();
            if (jedis.exists(key)) {
                jedis.del(key);
            }
        }catch (Exception e){
            //log.info("JedisUtil.delByKey(String key)异常："+e.getMessage());
        }finally {
            disConnect(jedis);
        }
    }

    /**
     * 根据key获取过期时间
     *
     * @param key
     * @return
     */
    public long getTimeOutByKey(String key) {
        Jedis jedis=null;
        try{
            jedis = getJedis();
            return jedis.ttl(key);
        }catch (Exception e){
            //log.info("JedisUtil.getTimeOutByKey(String key)异常："+e.getMessage());
            return 0;
        }finally {
            disConnect(jedis);
        }

    }

    /**
     * 清空数据 【慎用啊！】
     */
    public void flushDB(){
        Jedis jedis=null;
        try{
            jedis = getJedis();
            jedis.flushDB();
        }catch (Exception e){
            //log.info("JedisUtil.flushDB() 异常："+e.getMessage());
        }finally {
            disConnect(jedis);
        }

    }

    /**
     * 刷新过期时间
     * @param key
     * @param timeOut
     * @return
     */
    public long refreshLiveTime(String key, int timeOut) {
        Jedis jedis=null;
        try{
            jedis = getJedis();
            return jedis.expire(key, timeOut);
        }catch (Exception e){
            //log.info("JedisUtil.hasKey异常："+e.getMessage());
            return -1;
        }finally {
            disConnect(jedis);
        }
    }

    /**
     * 释放资源
     */
    public void disConnect(Jedis jedis) {
        if (jedis!=null){
            jedis.disconnect();
//            jedis.close();
        }
    }



    /**
     * 静态注入JedisPool连接池
     * 本来是正常注入JedisUtil，可以在Controller和Service层使用，但是重写Shiro的CustomCache无法注入JedisUtil
     * 现在改为静态注入JedisPool连接池，JedisUtil直接调用静态方法即可
     * https://blog.csdn.net/W_Z_W_888/article/details/79979103
     */
    private static JedisPool jedisPool;
    @Autowired
    public void setJedisPool(JedisPool jedisPool) {
        JedisUtil.jedisPool = jedisPool;
    }

    /**
     * 获取Jedis实例
     * @param
     * @return redis.clients.jedis.Jedis
     * @author dog_E
     * @date 2018/9/4 15:47
     */
    public static synchronized Jedis getResource() {
        try {
            if (jedisPool != null) {
                return jedisPool.getResource();
            } else {
                return null;
            }
        } catch (Exception e) {
            throw new CustomException("获取Jedis资源异常:" + e.getMessage());
        }
    }

    /**
     * 释放Jedis资源
     * @param
     * @return void
     * @author dog_E
     * @date 2018/9/5 9:16
     */
    public static void closePool() {
        try {
            jedisPool.close();
        } catch (Exception e) {
            throw new CustomException("释放Jedis资源异常:" + e.getMessage());
        }
    }

    /**
     * 获取redis键值-object
     * @param key
     * @return java.lang.Object
     * @author dog_E
     * @date 2018/9/4 15:47
     */
    public static Object getObject(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            String bytes = jedis.get(key);
            if (SUtils.isNotBlank(bytes)) {
                return bytes;
            }
        } catch (Exception e) {
            throw new CustomException("获取Redis键值getObject方法异常:key=" + key + " cause=" + e.getMessage());
        }
        return null;
    }

    /**
     * 设置redis键值-object
     * @param key
     * @param value
     * @return java.lang.String
     * @author dog_E
     * @date 2018/9/4 15:49
     */
    public static String setObject(String key, Object value) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.set(key.getBytes(), SerializableUtil.serializable(value));
        } catch (Exception e) {
            throw new CustomException("设置Redis键值setObject方法异常:key=" + key + " value=" + value + " cause=" + e.getMessage());
        }
    }

    /**
     * 设置redis键值-object-expiretime
     * @param key
     * @param value
     * @param expiretime
     * @return java.lang.String
     * @author dog_E
     * @date 2018/9/4 15:50
     */
    public static String setObject(String key, Object value, int expiretime) {
        String result;
        try (Jedis jedis = jedisPool.getResource()) {
            result = jedis.set(key, String.valueOf(value));
            if (Constant.RedisPrefixConstant.OK.equals(result)) {
                jedis.expire(key.getBytes(), expiretime);
            }
            return result;
        } catch (Exception e) {
            throw new CustomException("设置Redis键值setObject方法异常:key=" + key + " value=" + value + " cause=" + e.getMessage());
        }
    }

    /**
     * 获取redis键值-Json
     * @param key
     * @return java.lang.Object
     * @author dog_E
     * @date 2018/9/4 15:47
     */
    public static String getJson(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.get(key);
        } catch (Exception e) {
            throw new CustomException("获取Redis键值getJson方法异常:key=" + key + " cause=" + e.getMessage());
        }
    }

    /**
     * 设置redis键值-Json
     * @param key
     * @param value
     * @return java.lang.String
     * @author dog_E
     * @date 2018/9/4 15:49
     */
    public static String setJson(String key, String value) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.set(key, value);
        } catch (Exception e) {
            throw new CustomException("设置Redis键值setJson方法异常:key=" + key + " value=" + value + " cause=" + e.getMessage());
        }
    }

    /**
     * 设置redis键值-Json-expiretime
     * @param key
     * @param value
     * @param expiretime
     * @return java.lang.String
     * @author dog_E
     * @date 2018/9/4 15:50
     */
    public static String setJson(String key, String value, int expiretime) {
        String result;
        try (Jedis jedis = jedisPool.getResource()) {
            result = jedis.set(key, value);
            if (Constant.RedisPrefixConstant.OK.equals(result)) {
                jedis.expire(key, expiretime);
            }
            return result;
        } catch (Exception e) {
            throw new CustomException("设置Redis键值setJson方法异常:key=" + key + " value=" + value + " cause=" + e.getMessage());
        }
    }

    /**
     * 删除key
     * @param key
     * @return java.lang.Long
     * @author dog_E
     * @date 2018/9/4 15:50
     */
    public static Long delKey(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.del(key.getBytes());
        } catch (Exception e) {
            throw new CustomException("删除Redis的键delKey方法异常:key=" + key + " cause=" + e.getMessage());
        }
    }

    /**
     * 删除key
     * @param key
     * @return java.lang.Long
     * @author dog_E
     * @date 2018/9/4 15:50
     */
    public static Boolean delKeyBoolean(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * key是否存在
     * @param key
     * @return java.lang.Boolean
     * @author dog_E
     * @date 2018/9/4 15:51
     */
    public static Boolean exists(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.exists(key);
        } catch (Exception e) {
            throw new CustomException("查询Redis的键是否存在exists方法异常:key=" + key + " cause=" + e.getMessage());
        }
    }

    /**
     * 模糊查询获取key集合(keys的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，生产不推荐使用)
     * @param key
     * @return java.util.Set<java.lang.String>
     * @author dog_E
     * @date 2018/9/6 9:43
     */
    public static Set<String> keysS(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.keys(key);
        } catch (Exception e) {
            throw new CustomException("模糊查询Redis的键集合keysS方法异常:key=" + key + " cause=" + e.getMessage());
        }
    }

    /**
     * 模糊查询获取key集合(keys的速度非常快，但在一个大的数据库中使用它仍然可能造成性能问题，生产不推荐使用)
     * @param key
     * @return java.util.Set<java.lang.String>
     * @author dog_E
     * @date 2018/9/6 9:43
     */
    public static Set<byte[]> keysB(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.keys(key.getBytes());
        } catch (Exception e) {
            throw new CustomException("模糊查询Redis的键集合keysB方法异常:key=" + key + " cause=" + e.getMessage());
        }
    }


    /**
     * redis做hash的添加
     */
    public static boolean hset(String key, String field, String value){
        if(SUtils.isBlank(key) || SUtils.isBlank(field)){
            return false;
        }
        try (Jedis jedis = jedisPool.getResource()) {
            //If the field already exists, and the HSET just produced an update of the value, 0 is returned,
            //otherwise if a new field is created 1 is returned.
            Long statusCode = jedis.hset(key, field, value);
            if(statusCode > -1){
                return true;
            }
        } catch (Exception e) {
            throw new CustomException("模糊查询Redis的键集合keysB方法异常:key=" + key + " cause=" + e.getMessage());
        }
        return false;
    }

    /**
     * @Description: 获取hsah中field的value
     * @Author: @Dog_Elder
     * @Date: 2020/11/18 14:09
     * @param key: key
     * @param field: map中key
     * @return: map中value
     **/
    public static String hget(String key, String field){
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.hget(key, field);
        } catch (Exception e) {
            throw new CustomException("获取hsah中field的value方法异常:key=" + key + "field=" + field + " cause=" + e.getMessage());
        }
    }


    /**
     * @Description: hash 值 增或加
     * @Author: @Dog_Elder
     * @Date: 2020/11/19 14:35
     * @param key: key
     * @param field: map中key
     * @param value: 可以是正数 也可以是负数
     * @return: java.lang.Long
     **/
    public static Long hincrBy(String key, String field,long value){
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.hincrBy(key,field,value);
        } catch (Exception e) {
            throw new CustomException("获取hsah中field的value方法异常:key=" + key + "field=" + field + " cause=" + e.getMessage());
        }
    }


    /**
     * 获取过期剩余时间
     * @param key
     * @return java.lang.String
     * @author dog_E
     * @date 2018/9/11 16:26
     */
    public static Long ttl(String key) {
        Long result = -2L;
        try (Jedis jedis = jedisPool.getResource()) {
            result = jedis.ttl(key);
            return result;
        } catch (Exception e) {
            throw new CustomException("获取Redis键过期剩余时间ttl方法异常:key=" + key + " cause=" + e.getMessage());
        }
    }


}

    测试代码

    ps:无需关系Redis中的值 只用看你的java代码的执行结果接口 保证是10个成功就可以了

            boolean result = JedisUtil.hset("1", "1", "10");
        if (result) {
            System.out.println("商品初始化成功,商品id为1,skuId为1,数量10");
        } else {
            System.out.println("商品初始化失败");
        }
        ExecutorService service = Executors.newFixedThreadPool(10);
        Thread runnable1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                String stock = JedisUtil.hget("1", "1");
                if (Integer.parseInt(stock) < 0) {
                    return;
                }
                Long count = JedisUtil.hincrBy("1", "1", -1);
                if (count.intValue() < 0) {
                    return;
                }
                System.out.println("抢购成功");
            }
        });
        Thread runnable2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                String stock = JedisUtil.hget("1", "1");
                if (Integer.parseInt(stock) < 0) {
                    return;
                }
                Long count = JedisUtil.hincrBy("1", "1", -1);
                if (count.intValue() < 0) {
                    return;
                }
                System.out.println("抢购成功");
            }
        });
        Thread runnable3 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                String stock = JedisUtil.hget("1", "1");
                if (Integer.parseInt(stock) < 0) {
                    return;
                }
                Long count = JedisUtil.hincrBy("1", "1", -1);
                if (count.intValue() < 0) {
                    return;
                }
                System.out.println("抢购成功");
            }
        });
        service.submit(runnable1);
        service.submit(runnable2);
        service.submit(runnable3);
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String hget = JedisUtil.hget("1", "1");
        System.out.println(" redis 数量 = " + hget);
Dog_Elder
关注
专栏目录
java秒杀项目:mysql乐观锁+redis限流+redis缓存+kafka队列
云飞扬的博客
11-19 3175
最近学习了秒杀系统设计,已经将代码上传到github,不断优化,吞吐量达到5000,大家喜欢的话还希望多多star 安装和使用说明方法 首先要安装Java和maven,我的安装环境为: yunfeiyang@buaa:~$ mvn -v Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:47...
2024年最新《Redis实战篇》三、优惠券秒杀(2)
kOS0ym的博客
05-03 111
时间戳：31bit，以秒为单位，可以使用69年序列号：32bit，秒内的计数器，支持每秒产生2^32个不同ID。
利用redis实现redisson分布式锁，自定义注解形式
weixin_43861630的博客
10-09 425
我要实现的业务是根据年月生成自增的编码 添加所需包 <!-- redis 缓存操作 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </depende
分布式锁Redisson实战（二）自定义注解
qq_34412985的博客
01-30 206
package com.*.data.busisystem; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target({ElementType.M
自定义Redisson分布式锁
weixin_45608827的博客
10-11 213
1.0分布式锁应用代码 //zookeeper 分布锁 public static RLock getLock() { Config config = new Config(); //指定使用单节点部署方式 config.useSingleServer().setAddress("redis://127.0.0.1:6379");//.setPassword("mkxiaoer"); //获取RedissonClient对象 RedissonClient rediss
Redis实现分布式锁
qq_59776041的博客
08-15 374
分布式下如何实现集群共享的锁、如何用redis实现分布式锁来解决并发问题、redis中所得误删怎么解决、怎么用redis实现多重锁问题
redis使用以及Redisson
明耀的博客
04-08 553
<dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.10.6</version> </dependency> <dependency> <g...
RocketMQ学习(3) 秒杀实战
最新发布
weixin_43739821的博客
06-03 989
前置知识 QPS、jmeter压测 一般的秒杀架构如何设计 本项目结构设计 数据库 接收用户秒杀服务 pom和配置文件 SeckillController 处理秒杀服务(重点) pom和配置文件 Mysql、Redis数据同步 创建秒杀监听 方案一 在事务外面加锁 先查库存再减带来的并发问题 方案二 分布式锁 - mysql(行锁) 方案三 分布式锁 - redis setnx
Redis总结(7)---Redis的锁
weixin_38813363的博客
03-13 1367
Redis的锁Watch实现乐观锁set 分布式锁Redission Watch实现乐观锁 乐观锁给予CAS(Compare and Swap) 思想(比较并替换)，是不具有互斥性，不会产生锁等待而消耗资源，但是需要反复的重试，但是因为重试的机制，能比较快的响应。因此我们可以利用redis来实现乐观锁 实现思路： 1.利用redis的watch功能，监控key的状态 2.获取redisKey的值 3.创建redis事物 4.給key的值+1 5.执行事物，如果key的值被修改过则回滚，key值不会变 原理：
【Redis最佳实践】使用DCS Redis实现分布式锁
amy_xing01的博客
08-07 651
Redis加锁操作简单，使用SET、GET、DEL等几条简单命令即可实现锁的获取和释放。这里介绍使用DCS Redis实现分布式锁。 目录 场景介绍 加锁实现​  测试代码 实践指导 运行结果 不加锁场景 华为云DCS Redis介绍 场景介绍 很多互联网场景（如商品秒杀，论坛回帖盖楼等），需要用加锁的方式，以对某种资源进行顺序访问控制。如果应用服务集群部署，则涉及到对分布式应...
高并发编程：秒杀—无锁、排他锁、乐观锁、redis缓存的逐步演变
linjingyg的博客
12-03 313
　　环境： 　　jdk1.8；spring boot2.0.2；Maven3.3 　　摘要说明： 　　在实际开发过程中往往会出现许多高并发场景，秒杀，抢红包，抢优惠卷等； 　　其中： 　　秒杀场景的特点就是单位时间涌入用户量极大，商品数少，且要保证不可超量销售； 　　秒杀产品的本质就是减库存； 　　秒杀场景常用的解决方案有限流、削峰、拓展等 　　本篇以秒杀场景为依据来主要从代码开发的角度阐述从无锁——》排他锁——》共享锁——》缓存中间件的一步步升级来不断完善及优化；同时也针对整体架构提出..
springboot 集成 redis分布式锁
weixin_49451928的博客
03-31 249
【代码】springboot 集成 redis分布式锁。
高并发编程之高并发场景：秒杀（无锁、排他锁、乐观锁、redis缓存的逐步演变）
热门推荐
叶落自飘零的博客
10-19 5万+
环境： jdk1.8；spring boot2.0.2；Maven3.3 摘要说明： 在实际开发过程中往往会出现许多高并发场场景，秒杀，强红包，抢优惠卷等； 其中： 秒杀场景的特点就是单位时间涌入用户量极大，商品数少，且要保证不可超量销售； 秒杀产品的本质就是减库存； 秒杀场景常用的解决方案有限流、削峰、拓展等 本篇以秒杀场景为依据来主要从代码开发的角度阐述从无锁——》排他锁——》...
redission分布式锁实现_来吧，展示！Redis的分布式锁及其实现Redisson的全过程
weixin_39670441的博客
11-26 235
前言分布式锁是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要互斥来防止彼此干扰来保证一致性，这个时候，便需要使用到分布式锁。什么是分布式锁1.在分布式环境中使用到的锁就是分布式锁2.在分布式环境中对不同应用程序操作的共享资源进行加锁就是分布式锁分布式环境1.同一个...
【记录springBoot整合 redis与redisson的配置及使用】
qq_42612459的博客
11-18 5239
redisson配置文件 配置文件 pom.xml <!-- redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- r
Redis 连接错误/连接池配置错误redisConnectionFactory
大能人powerman的博客
11-11 2万+
Redis 连接错误/连接池配置错误 【说明】：项目采用Redia在redis方面采用RedisTemplate进行方法调用，在配置中采用RedisConnectionFactory和redis连接池 【错误现象】 项目启动不开 Error starting ApplicationContext. To display the conditions report re-run your application with ‘debug’ enabled. 2020-11-11 17:53:58
redisTemplate序列化工具类
hacker_Lees的博客
09-30 473
import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.RedisSerializer; import javax.annotation.PostConstruct; import javax.annotation.Resour.
SpringBoot+Redisson连接使用Docker部署的Redis集群
weixin_44509349的博客
06-11 2231
Docker部署redis集群（一主一从）。使用SpringBoot+Redisson进行连接测试。
Redis单线程为什么需要加锁
qq_39612954的博客
10-19 4509
首先需要说明一点的是：我们一直在强调 redis 是单线程，只是在处理我们的网络请求的时候只有一个线程来处理，一个正式的Redis Server运行的时候肯定是不止一个线程的。 为什么redis是单线程的？   官方FAQ表示，因为Redis是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章地采用单线程的方案了。 为什么redis需要加锁？   我们需要注意的是：redis是单线程这是毋庸置疑的。red
Redis高并发秒杀方案详解
"Redis瞬时高并发秒杀方案总结" 在设计高并发的秒杀系统时，Redis作为一款高性能的键值存储数据库，因其高效的数据结构和操作特性，成为了解决此类问题的理想选择。以下是对Redis在高并发秒杀场景中应用的详细解释...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值