Redis3

lmy410

已于 2023-04-28 17:17:57 修改

阅读量60

点赞数

分类专栏： Redis 文章标签： java redis 数据库

于 2023-04-27 01:41:27 首次发布

本文链接：https://blog.csdn.net/lmy410/article/details/130388458

版权

Redis 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

java连接redis
springboot连接redis操作。
完成缓存操作
redis实现分布式锁

1. 连接redis–2014

默认有三种方式连接redis.

第一种:jedis—传统的项目–ssm

第二种:lettuce:---->刚出现没有多久就被springboot整合进来。

第三种:springboot连接redis

1.1 jedis操作redis服务器

（1）引入jedis依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.3.1</version> 
</dependency>

（2）编写相关的代码
在这里插入图片描述

package com.lmy;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class TestJedis {
    //必须保证：虚拟机防火墙关闭  redis允许远程连接0.0.0.0  保护策略去除
    @Test
    public void test01(){
        //Jedis(String host,int port)
        Jedis jedis = new Jedis("192.168.65.131", 6379); //.var
        //该类包含很多对redis操作的方法--而这些方法和原来我们使用的命令一样
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);



        //对String数据类型操作
        String set = jedis.set("k4", "hello 李梦瑶");
        System.out.println("set:" +set);
        String k4 = jedis.get("k4");
        System.out.println("k4:" +k4);
        String k5 = jedis.setex("k5", 60," hello lmy");



        //对hash数据类型操作
        Map<String, String> map = new HashMap<>();
        map.put("name","美羊羊");
        map.put("age","21");
        map.put("sex","女");
        jedis.hset("k6",map);

        Map<String, String> map1 = jedis.hgetAll("k6");
        System.out.println(map1);



        //list队列
        jedis.lpush("k7","李梦瑶","马群超","熊大","熊二");
        List<String> k7 = jedis.lrange("k7", 0, -1);
        System.out.println(k7);


        jedis.close();

    }
}

每次使用jedis对象时都需要自己创建，当使用完后，需要关闭该对象。===>jedis中也存在连接池.

2.2 jedis连接池的使用

package com.lmy;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.Set;

public class TestJedis {

    @Test
    public void testPool(){
        //连接池的配置信息
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(10); //最多的连接个数
        config.setMaxIdle(10); //最多的空闲的连接个数
        config.setMinIdle(2); //最小的空闲的连接个数】
        config.setTestOnBorrow(true); //在获取连接对象时，是否验证该连接对象的连通性
        //创建连接池对象
        JedisPool jedisPool = new JedisPool(config, "192.168.65.131", 6379);

        Jedis jedis = jedisPool.getResource();
        //清空当前的库
        jedis.flushDB();

        String set = jedis.set("k1", "v1");
        String k1 = jedis.get("k1");
        System.out.println(k1);

        jedis.close(); //归还连接池
    }

}

1.3 测试jedis使用和不使用连接池的效率

package com.lmy;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import java.util.Set;

public class TestJedis {

    @Test
    public void test03(){
        //连接池的配置信息
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(10); //最多的连接个数
        config.setMaxIdle(10); //最多的空闲的连接个数
        config.setMinIdle(2); //最小的空闲的连接个数】
        config.setTestOnBorrow(true); //在获取连接对象时，是否验证该连接对象的连通性
        //创建连接池对象
        JedisPool jedisPool = new JedisPool(config, "192.168.65.131", 6379);

        long start = System.currentTimeMillis();
        //Jedis（String host,int port)
        for (int i = 0; i < 1000; i++) {
            Jedis jedis = jedisPool.getResource();
            String ping = jedis.ping();
            System.out.println(ping);
            jedis.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end-start));

    }
    

    @Test
    public void test02(){
        long start = System.currentTimeMillis();
        //Jedis（String host,int port)
        for (int i = 0; i < 1000; i++) {
            Jedis jedis = new Jedis("192.168.65.131", 6379);
            String ping = jedis.ping();
            System.out.println(ping);
            jedis.close();
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end-start));
    }
}

1.4 springboot整合redis

springboot在整合redis时提高两个模板类,StringRedisTemplate和RedisTemplate.以后对redis的操作都在该模板类中。StringRedisTemplate是RedisTemplate的子类。

<!--redis相关的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

修改配置文件

# redis的配置信息
spring.redis.host=192.168.65.131
spring.redis.port=6379
# 最多的获取数
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

测试:

package com.lmy;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

@SpringBootTest
class Qy163SpringbootRedis1ApplicationTests {

    //因为springboot整合redis时会把stringRedisTemplate创建并交于spring容器管理
    @Autowired
    StringRedisTemplate redisTemplate;
    @Test
    void contextLoads() {
        //关于key的操作
       /* Set<String> keys = redisTemplate.keys("*"); //获取所有的key
        System.out.println("keys:" + keys);
        Boolean hasKey = redisTemplate.hasKey("k1"); //判断是否存在指定的key
        System.out.println("判断是否存在指定的key:" + hasKey);
        Boolean k1 = redisTemplate.delete("k1"); //删除指定的key
        System.out.println("是否删除指定的key成功：" + k1);



        //操作字符串---StringRedisTemplate会把对每一种数据的操作单独封装成一个类
        ValueOperations<String, String> forValue = redisTemplate.opsForValue();//ValueOperations专门操作字符串
        forValue.set("k1","你好，小朋友");

        String k11 = forValue.get("k1");
        System.out.println("k1:" + k11);
        Boolean aBoolean = forValue.setIfAbsent("k2", "我是熊大");
        System.out.println("是否存入成功：" + aBoolean);

        //incr
        //Long k3 = forValue.increment("k3");//10 +1 = 11
        Long k3 = forValue.increment("k3",20);//11 +20 = 31
        System.out.println("k3:" + k3);*/


        //可以hash操作
        HashOperations<String, Object, Object> forHash = redisTemplate.opsForHash();
        forHash.put("k1","name","熊大");
        forHash.put("k1","age","21");
        forHash.put("k1","sex","男");
        HashMap<String, String> map = new HashMap<>();
        map.put("name","熊二");
        map.put("age","18");
        map.put("sex","男");
        forHash.putAll("k2",map);

        Map<Object, Object> k1 = forHash.entries("k1");
        System.out.println("k1:" + k1);
        Map<Object, Object> k2 = forHash.entries("k2");
        System.out.println("k2:" + k2);

        Set<Object> k11 = forHash.keys("k1");
        System.out.println("k1:" + k11);
        List<Object> k111 = forHash.values("k1");
        System.out.println("k1:" + k111);
        Set<Object> k22 = forHash.keys("k2");
        System.out.println("k2:" + k22);
        List<Object> k222 = forHash.values("k2");
        System.out.println("k2:" + k222);
    }

}

1.4.2 RedisTemplate

它是StringRedisTemplate的父类，它类可以存储任意数据类型，但是任意类型必须序列化，默认采用的是jdk的序列化方式。jdk序列化方式阅读能力差，而且占用空间大.
我们在使用是一般需要人为指定序列化方式。

package com.lmy;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

@SpringBootTest
class Qy163SpringbootRedis1ApplicationTests2 {
    @Autowired
    RedisTemplate redisTemplate;
    //Caused by: org.springframework.core.serializer.support.SerializationFailedException   该对象的实体类要实现序列化
    //stringRedisTemplate  实体不用序列化是因为String本身就实现了序列化
    //因为user对象在jvm内存中，---放入redis服务器--持久化到硬盘上
    //key和value都是乱码-- 因为它默认采用的序列化方式jdk的序列化方式，但是阅读不方便，我们一般不用jdk的序列化方式
    @Test
    public void test01(){
        redisTemplate.setKeySerializer(new StringRedisSerializer());//解决key乱码
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());//解决value乱码
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set("user",new User(1,"李梦瑶","平顶山"));

        Object user = valueOperations.get("user");
        System.out.println(user);
    }

}

如果每次使用都人为指定序列化方式，统一设置redisTemplate的序列化

package com.ykq;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @program: qy163-springboot-redis
 * @description:
 * @author: 闫克起2
 * @create: 2023-04-24 16:15
 **/
@Configuration
public class RedisConfig {
    //比如验证码
    @Bean //该方法的返回对象交于spring容器管理
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        //field序列化  key field  value
        template.setHashKeySerializer(redisSerializer);
        return template;
    }
}

上面的连接都是连接的单机版的redis,真实项目它们的redis都是集群模式.

1.5 springboot连接集群

spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0
# 设置redis重定向的次数---根据主节点的个数
spring.redis.cluster.max-redirects=3
spring.redis.cluster.nodes=192.168.65.131:7001,192.168.65.131:7002,192.168.65.131:7003,192.168.65.131:7004,192.168.65.131:7005,192.168.65.131:7006

2. redis的应用场景

2.1 redis可以作为缓存

(1) 缓存的原理

(2)缓存的作用:

减少访问数据库的频率。–提高系统的性能。

(3)什么样的数据适合放入缓存

查询频率高的
修改频率低的
数据安全性要求低的。

(4)如何使用缓存

必要前提：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.lmy</groupId>
    <artifactId>qy163-springboot-redis2</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>qy163-springboot-redis2</name>
    <description>qy163-springboot-redis2</description>
    <properties>
        <java.version>8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

(3)配置文件

server.port=8888

spring.datasource.url=jdbc:mysql:///homework1
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

# redis的配置信息
spring.redis.host=192.168.65.131
spring.redis.port=6379
# 最多获取数
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

(3)servie

package com.lmy.service.impl;
import com.lmy.mapper.DeptMapper;
import com.lmy.pojo.Dept;
import com.lmy.service.DeptService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

@Service
public class DeptServiceImpl implements DeptService {

    @Autowired
    DeptMapper deptMapper;

    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    @Override
    public Dept getById(Integer id) {
        ValueOperations<String, Object> forValue = redisTemplate.opsForValue();
        //查询缓存
        Object o = forValue.get("dept::" + id);
        if (o != null){ //缓存命中
            return (Dept) o;
        }
        Dept dept = deptMapper.selectById(id);
        //查询到应该放入缓存
        if (dept != null){
            forValue.set("dept::" + id,dept);
        }

        return dept;
    }
}

使用springboot连接redis并且把我们原来讲的每个数据类型对应的命令找到对应的方法。

springboot连接redis集群

redis作为缓存使用

3. 完成缓存操作

3.1 缓存

当执行增删改操纵时必须保证缓存和数据库数据一致性。—删除缓存

4. redis实现分布式锁

必要前提：

4.1通过使用jmeter压测工具测试：

(1) service层代码（没加锁）

package com.lmy.service;
import com.lmy.dao.StockDao;
import com.lmy.entity.Stock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


@Service
public class StockService_lock_syn {
    @Autowired
    private StockDao stockDao;
    public static Object o=new Object();
   
    public  String jianStock(Integer pid){
            //1. 查询指定的商品库存
        	Stock stock = stockDao.selectById(pid);
        	if (stock.getNum() > 0) {
            //2.库存减1
            stock.setNum(stock.getNum() - 1);
            stockDao.updateById(stock);
            System.out.println("库存剩余数量:" + stock.getNum());
            return "减库存成功";
        } else {
            System.out.println("库存不足");
            return "库存减失败";
        }  
    }
}

a.直接浏览器访问测试

>

b.使用jmeter压测工具测试

同一个库存数被多个线程卖，线程安全问题。

-----思考:之间出现线程安全问题时如何解决。

可以使用锁解决:----synchronized和Lock锁

(2)service层代码（加锁----Lock锁）

package com.lmy.service;
import com.lmy.dao.StockDao;
import com.lmy.entity.Stock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Service
public class StockService_lock_syn {
    @Autowired
    private StockDao stockDao;
    public static Object o=new Object();
    Lock lock=new ReentrantLock();
    public  String jianStock(Integer pid){
        try {
            lock.lock();//加锁
            //1. 查询指定的商品库存
            Stock stock = stockDao.selectById(pid);
            if (stock.getNum() > 0) {
                //2.库存减1
                stock.setNum(stock.getNum() - 1);
                stockDao.updateById(stock);
                System.out.println("库存剩余数量:" + stock.getNum());
                return "减库存成功";
            } else {
                System.out.println("库存不足");
                return "库存减失败";
            }
        }
        finally {
            lock.unlock(); //释放锁
        }

    }
}

a.使用jmeter压测工具测试

上面的synchronized或Lock锁，是否适合集群模式|分布式系统?
答：不适合,因为synchronized都是基于JVM的本地锁。

(3)synchronized、Lock锁，不适合集群、分布式系统

synchronized或Lock锁是不适合集群模式|分布式系统,因为synchronized都是基于JVM的本地锁。

a.需要在idea中跑项目的集群

b.配置nginx

c.启动nginx

d.jmeter压测

e.两台集群出现重卖问题。

4.2 使用redis来解决分布式锁

在这里插入图片描述

package com.lmy.service;
import com.lmy.dao.StockDao;
import com.lmy.entity.Stock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Service
public class StockService_lock_syn {

    //  2.0
    @Autowired
    private StockDao stockDao;
    @Autowired
    private StringRedisTemplate redisTemplate;

    public  String jianStock(Integer pid) {
        //占锁
        ValueOperations<String, String> forValue = redisTemplate.opsForValue();
        //Boolean aBoolean = forValue.setIfAbsent("product::" + pid, "", 30, TimeUnit.SECONDS);
        //占锁失败
        while (!forValue.setIfAbsent("product::" + pid, "", 30, TimeUnit.SECONDS)){
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //占锁成功
        try {
            //1. 查询指定的商品库存
            Stock stock = stockDao.selectById(pid);
            if (stock.getNum() > 0) {
                //2.库存减1
                stock.setNum(stock.getNum() - 1);
                stockDao.updateById(stock);
                System.out.println("库存剩余数量:" + stock.getNum());
                return "减库存成功";
            } else {
                System.out.println("库存不足");
                return "库存减失败";
            }
        }finally {
            //释放锁资源
            redisTemplate.delete("product::" + pid);
        }
    }


   /*
   // 1.0  使用lock锁只能解决单机锁的问题，如果是集群服务--无法解决
    @Autowired
    private StockDao stockDao;
   //public static Object o=new Object();
    Lock lock=new ReentrantLock();
    public  String jianStock(Integer pid){
        try {
            lock.lock();//加锁
            //1. 查询指定的商品库存
            Stock stock = stockDao.selectById(pid);
            if (stock.getNum() > 0) {
                //2.库存减1
                stock.setNum(stock.getNum() - 1);
                stockDao.updateById(stock);
                System.out.println("库存剩余数量:" + stock.getNum());
                return "减库存成功";
            } else {
                System.out.println("库存不足");
                return "库存减失败";
            }
        }
        finally {
            lock.unlock(); //释放锁
        }

    }
        } */

    }

如果你的业务代码的执行时间超过30s，当前线程删除的是其他线程的锁资源。 –watchDog机制

每个10s检测当前线程是否还持有所资源，如果持有则为当前线程延迟。
----1.可以自己设置watchDog机制，----2.第三方Redission完美的解决分布式锁.

4.3 redisson完美解决redis超时问题

(1) 依赖

<dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.4</version>
</dependency>

(2) main函数

package com.lmy;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class RedisLockQy163Application {

    public static void main(String[] args) {
        SpringApplication.run(RedisLockQy163Application.class, args);
    }

    @Bean //创建redisson交于spring容器来管理
    public RedissonClient redisson() {
        Config config = new Config();
        //config.setLockWatchdogTimeout(300);
        config.useSingleServer().setAddress("redis://192.168.65.131:6379");
        RedissonClient redisson = Redisson.create(config);
        return redisson;
    }
}

(3) 使用

package com.lmy.service;
import com.lmy.dao.StockDao;
import com.lmy.entity.Stock;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

@Service
public class StockService_lock_syn {

    //3.0
    @Autowired
    private StockDao stockDao;
    @Autowired
    private RedissonClient redisson;
    public  String jianStock(Integer pid) {
        RLock lock = redisson.getLock("product::" + pid);
        try {
            lock.lock(30,TimeUnit.SECONDS);//加锁
            //1. 查询指定的商品库存
            Stock stock = stockDao.selectById(pid);
            if (stock.getNum() > 0) {
                //2.库存减1
                stock.setNum(stock.getNum() - 1);
                stockDao.updateById(stock);
                System.out.println("库存剩余数量:" + stock.getNum());
                return "减库存成功";
            } else {
                System.out.println("库存不足");
                return "库存减失败";
            }
        }
        finally {
            lock.unlock(); //释放锁
        }
    }
}

lmy410

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Redis3

它是StringRedisTemplate的父类，它类可以存储任意数据类型，但是任意类型必须序列化，默认采用的是jdk的序列化方式。----1.可以自己设置watchDog机制，----2.第三方Redission完美的解决分布式锁.上面的连接都是连接的单机版的redis,真实项目它们的redis都是集群模式.如果你的业务代码的执行时间超过30s，当前线程删除的是其他线程的锁资源。可以使用锁解决:----synchronized和Lock锁。-----思考:之间出现线程安全问题时如何解决。
复制链接

扫一扫