redisson去解决高并发哇塞大嘴好帅

最新推荐文章于 2024-05-09 07:00:00 发布

哇塞大嘴好帅(DaZuiZui)

最新推荐文章于 2024-05-09 07:00:00 发布

阅读量346

点赞数

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

本文链接：https://blog.csdn.net/qq_40102411/article/details/122446817

版权

Redis 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

redisson去解决高并发哇塞大嘴好帅

我爱大嘴网 www.dazuizui.com/hblog 哇塞大嘴好帥

1.使用redisson去解决高并发秒杀

使用redisson实现锁续命来解决高并发问题,

**锁续命：**线程A和线程A对同一key进行加锁，假如线程A枷锁成功，进行操作然后释放锁，线程B去加锁。在加锁的过程中会开启一个线程每隔10秒检测下锁是否过期，如果过期了那么就延长锁的时间。

pom.xml

  <!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.6.5</version>
        </dependency>
        <!-- 操作Jedis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.3.3.RELEASE</version>
        </dependency>




        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!--web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

配置文件

spring:
  redis:
    # Redis Url
    host: 127.0.0.1
    # Redis 端口
    port: 6379
    # 设置数据库序号
    database: 0

启动类

package com.dazuizui.gaobingfamiaosha;

import org.omg.IOP.Codec;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.codec.JsonJacksonCodec;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@SpringBootApplication

@Configuration
public class GaobingfamiaoshaApplication {
    @Bean
    public Redisson redissonClient() {
        Config conf = new Config();
        //单节点模式
        SingleServerConfig singleServerConfig = conf.useSingleServer().setDatabase(0);

        //设置连接地址：redis://127.0.0.1:6379
        singleServerConfig.setAddress("redis://127.0.0.1:6379");
        //设置连接密码
        //singleServerConfig.setPassword("password");

        RedissonClient redissonClient = Redisson.create(conf);
        return (Redisson) Redisson.create(conf);
    }


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



}

controller

package com.dazuizui.gaobingfamiaosha.controller;

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {
    @Autowired
    private Redisson redisson;
    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("/test1")
    public String getts1t(){
        redisTemplate.opsForValue().set("B",10);
        int kc = (int) redisTemplate.opsForValue().get("B");
        return  kc+"";
    }

    @GetMapping("/test")
    public String gettst(){
        RLock rLock = redisson.getLock("A");
        try {
            rLock.lock();
            int kc = (int) redisTemplate.opsForValue().get("B");
            if (kc > 0){
                redisTemplate.opsForValue().set("B",kc-1);
                System.out.println("购买成功");
            }else{
                System.out.println("购买失败");
            }
        }finally {
            rLock.unlinkAsync();
        }
        return "asd";
    }
}

2. 当redis主从切换锁key丢失解决

解决方案A redlock

redlock就是把redis节点超过半数加锁成功才算加锁成功。

3.缓存和数据库数据通过分布式锁保持一致

写锁多个线程访问会排队执行

@GetMapping("/test")
public String gettst(){
    RReadWriteLock rw = redisson.getReadWriteLock("A");
    RLock rLock = rw.writeLock();
    try {
        rLock.lock();
        int kc = (int) redisTemplate.opsForValue().get("B");
        if (kc > 0){
            redisTemplate.opsForValue().set("B",kc-1);
            System.out.println("购买成功");
        }else{
            System.out.println("购买失败");
        }
    }finally {
        rLock.unlinkAsync();
    }
    return "asd";
}

读锁多个线程同时执行不会有任何干扰，他们会并行执行

@GetMapping("/test")
public String gettst(){
    RReadWriteLock rw = redisson.getReadWriteLock("A");
    RLock rLock = rw.readLock();
    try {
        rLock.lock();
        int kc = (int) redisTemplate.opsForValue().get("B");
        if (kc > 0){
            redisTemplate.opsForValue().set("B",kc-1);
            System.out.println("购买成功");
        }else{
            System.out.println("购买失败");
        }
    }finally {
        rLock.unlinkAsync();
    }
    return "asd";
}

4redission连接哨兵集群

    @Bean
    public Redisson redissonClient() {
        Config conf = new Config();
        //单节点模式
        SentinelServersConfig sentinelServersConfig = conf.useSentinelServers().setDatabase(0);

        //设置连接地址：redis://127.0.0.1:6379
        sentinelServersConfig.setMasterName("master name");
        sentinelServersConfig.setPassword("passowrd");
        sentinelServersConfig.addSentinelAddress("redis://ip:port");
   

        RedissonClient redissonClient = Redisson.create(conf);
        return (Redisson) Redisson.create(conf);
    }