Multi-threading is for better utilization CPU, and for redis the main bottleneck is memory or network bandwidth rather than CPU CPU, and even single-threaded can through multiplexing and non-blocking IO concurrently handle client requests, initially single-threaded maintenance and development are simpler

For example, when a hash set contains tens of thousands of elements, then the del command will cause the Redis main thread to stall

The thread will not be released for a long wait, similar to adding a synchronized lock, you can imagine under high concurrency, the program will be super blocked

Generally CPU and memory are not a problem, network IO is the main problem

Although some command operations can be executed by background threads or child processes (such as data deletion, snapshot generation, AOF rewrite). However, from network IO handling to the actual read and write command handling, all are completed by a single thread. The performance bottleneck of Redis sometimes appears in network IO handling, that is, the speed at which a single main thread handles network requests cannot keep up with the speed of the underlying network hardware. To deal with this problem:

adopt multiple IO threads to handle network requests, improving the parallelism of network request handling,Redis6/7 is the method adopted

That is, network IO is multi-threaded, the thread that actually does the work is still single-threaded

1. connections, establishedSocketconnection

IO threads read and parse, such as whether the network is connected, whether the IP is allowed, whether the firewall is allowed

File descriptor FD handle

What is IO multiplexing

"文件句柄就绪"Usually refers to the file descriptor (file descriptor) or file handle (file handle) in the operating system being in a state whereI/Ooperations can be performed.

1. Setio-thread-do-readsThe configuration item is yes, which means multithreading is enabled.

2. Set the number of threads. Regarding the setting of the thread count, the official recommendation is that if it is a 4 core CPU, it is recommended to set the thread count to 2 or 3, and if it is an 8 core CPU, it is recommended to set the thread count to 6. The thread count must be less than the number of machine cores. A larger thread count is not always better.

A larger thread count is not always better

Directly configure it as an empty string in the configuration file

Alibaba Cloud Specification

1. redis-cli xxxx Add at the end --bigkeys Although--bigkeysthe command can help you find some big keys, when the size of the key exceeds a certain limit, it may not provide efficient performance and may even have a negative impact on the stability and overall performance of the Redis instance.

2. memory usage key

Get from redis, if redis is empty then get from mysql

@Service
@Slf4j
public class UserService {
    public static final String CACHE_KEY_USER = "user:";
    @Resource
    private UserMapper userMapper;
    @Resource
    private RedisTemplate redisTemplate;

    /**
     * The business logic is not written wrong, for small and medium companies(QPS《=1000)can be used, but big companies cannot
     * @param id
     * @return
     */
    public User findUserById(Integer id)
    {
        User user = null;
        String key = CACHE_KEY_USER+id;

        //1 First from redis query inside, if there is a direct return result, if not then query mysql
        user = (User) redisTemplate.opsForValue().get(key);

        if(user == null)
        {
            //2 redis no data inside, continue query mysql
            user = userMapper.selectByPrimaryKey(id);
            if(user == null)
            {
                //3.1 redis+mysql no data at all
                //You refine it specifically, to prevent multiple penetration. Our business rule stipulates, record the one causing penetration key write back redis
                return user;
            }else{
                //3.2 mysql yes, need to write data back to redis，ensure the next cache hit rate
                redisTemplate.opsForValue().set(key,user);
            }
        }
        return user;
    }


    /**
     * strengthen and supplement, to avoid sudden key expiration, overwhelming the mysql，Do some prevention, try to avoid breakdown situations.
     * @param id
     * @return
     */
    public User findUserById2(Integer id)
    {
        User user = null;
        String key = CACHE_KEY_USER+id;

        //1 First from redis query inside, if there is a direct return result, if not then query mysql，
        // Number 1 query redis，before locking
        user = (User) redisTemplate.opsForValue().get(key);
        if(user == null) {
            //2 Used by big companies, for high QPS optimization, lock first upon entry, ensure one request operation, let the outside redis wait a bit, avoid breakdown mysql
            synchronized (UserService.class){
                //Number 2 query redis，after locking
                user = (User) redisTemplate.opsForValue().get(key);
                //3 second check redis still null，can query mysql completed(mysql by default has data)
                if (user == null) {
                    //4 query mysql get data(mysql by default has data)
                    user = userMapper.selectByPrimaryKey(id);
                    if (user == null) {
                        return null;
                    }else{
                        //5 mysql has data inside, need to write back redis，complete the data consistency synchronization work
                        redisTemplate.opsForValue().setIfAbsent(key,user,7L,TimeUnit.DAYS);
                    }
                }
            }
        }
        return user;
    }
}

Not recommended, in business mysql is used as the base data, ensure final interpretation

Likewise multi-threaded

First deleted thereidsdata, then letmysqlperformed the update,mysqlaccessed the data before the update finished, the access got the old value, and would write the old value back toredis, the earlier deletion was wasted, causing the newly updated data not synced toredis,redisthe data has always been dirty, use delayed double delete to solve, that is atmysqldelete redis again after update, the delayed deletion time needs to be estimated

Solution: delayed double delete strategy

Delete twice before and after updating mysql. The sleep time of thread A responsible for deletion must be greater than the time for thread B to write to redis cache, to prevent other threads from reading old data and writing to redis without it being deleted (second deletion: make deletion asynchronous to avoid throughput reduction)

• How long should the deletion sleep

• Synchronous elimination strategy, how to handle throughput reduction

Make deletion asynchronous to avoid throughput reduction

1. Exception situation: under multithreading, order gets scrambled
2. Exception situation: Redis update fails, Redis reads dirty data

The problem is still reading the old value, but after MySQL finishes updating, the old value will be replaced, and the next request will get the latest value, which will not cause other new problems

But if the deletion fails, there is a problem

• MySQL configuration modification

Enable the binlog writing function of MySQL

Afterwards it will become ON

Create a new canal account and grant authorization select * from mysql.user

DROP USER IF EXISTS 'canal'@'%'; CREATE USER 'canal'@'%' IDENTIFIED BY 'canal';   GRANT ALL PRIVILEGES ON . TO 'canal'@'%' IDENTIFIED BY 'canal';   FLUSH PRIVILEGES; SELECT * FROM mysql.user;

1. Download the deployer version and extract it to the/mycanalpath
2. Configuration Fill in master with your own MySQL address Replace the account with the one you created earlier

<dependency>
    <groupId>com.alibaba.otter</groupId>
    <artifactId>canal.client</artifactId>
    <version>1.1.0</version>
</dependency>


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

public class RedisUtils
{
    public static final String  REDIS_IP_ADDR = "192.168.111.185";
    public static final String  REDIS_pwd = "111111";
    public static JedisPool jedisPool;

    static {
        JedisPoolConfig jedisPoolConfig=new JedisPoolConfig();
        jedisPoolConfig.setMaxTotal(20);
        jedisPoolConfig.setMaxIdle(10);
        jedisPool=new JedisPool(jedisPoolConfig,REDIS_IP_ADDR,6379,10000,REDIS_pwd);
    }

    public static Jedis getJedis() throws Exception {
        if(null!=jedisPool){
            return jedisPool.getResource();
        }
        throw new Exception("Jedispool is not ok");
    }

}

public class RedisCanalClientExample
{
    public static final Integer _60SECONDS = 60;
    public static final String  REDIS_IP_ADDR = "192.168.111.185";

    private static void redisInsert(List<Column> columns)
    {
        JSONObject jsonObject = new JSONObject();
        for (Column column : columns)
        {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
            jsonObject.put(column.getName(),column.getValue());
        }
        if(columns.size() > 0)
        {
            try(Jedis jedis = RedisUtils.getJedis())
            {
                jedis.set(columns.get(0).getValue(),jsonObject.toJSONString());
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }


    private static void redisDelete(List<Column> columns)
    {
        JSONObject jsonObject = new JSONObject();
        for (Column column : columns)
        {
            jsonObject.put(column.getName(),column.getValue());
        }
        if(columns.size() > 0)
        {
            try(Jedis jedis = RedisUtils.getJedis())
            {
                jedis.del(columns.get(0).getValue());
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    private static void redisUpdate(List<Column> columns)
    {
        JSONObject jsonObject = new JSONObject();
        for (Column column : columns)
        {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
            jsonObject.put(column.getName(),column.getValue());
        }
        if(columns.size() > 0)
        {
            try(Jedis jedis = RedisUtils.getJedis())
            {
                jedis.set(columns.get(0).getValue(),jsonObject.toJSONString());
                System.out.println("---------update after: "+jedis.get(columns.get(0).getValue()));
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    public static void printEntry(List<Entry> entrys) {
        for (Entry entry : entrys) {
            if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
                continue;
            }

            RowChange rowChage = null;
            try {
                //Get the changed row data
                rowChage = RowChange.parseFrom(entry.getStoreValue());
            } catch (Exception e) {
                throw new RuntimeException("ERROR ## parser of eromanga-event has an error,data:" + entry.toString(),e);
            }
            //Get the change type
            EventType eventType = rowChage.getEventType();
            System.out.println(String.format("================&gt; binlog[%s:%s] , name[%s,%s] , eventType : %s",
                    entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                    entry.getHeader().getSchemaName(), entry.getHeader().getTableName(), eventType));

            for (RowData rowData : rowChage.getRowDatasList()) {
                if (eventType == EventType.INSERT) {
                    redisInsert(rowData.getAfterColumnsList());
                } else if (eventType == EventType.DELETE) {
                    redisDelete(rowData.getBeforeColumnsList());
                } else {//EventType.UPDATE
                    redisUpdate(rowData.getAfterColumnsList());
                }
            }
        }
    }


    public static void main(String[] args)
    {
        System.out.println("---------O(∩_∩)O哈哈~ initCanal() main方法-----------");

        //=================================
        // Create the link canal Server side
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress(REDIS_IP_ADDR,
                11111), "example", "", "");
        int batchSize = 1000;
        //Idle no load counter
        int emptyCount = 0;
        System.out.println("---------------------canal init OK，开始监听mysql变化------");
        try {
            connector.connect();
            //connector.subscribe(".*\\..*");
            //The more monitoring,the slower the write back,Only guarantee dual write consistency for important data
            connector.subscribe("bigdata.t_user");
            connector.rollback();
            int totalEmptyCount = 10 * _60SECONDS;
            while (emptyCount < totalEmptyCount) {
                System.out.println("我是canal，每秒一次正在监听:"+ UUID.randomUUID().toString());
                Message message = connector.getWithoutAck(batchSize); // Get a specified amount of data
                long batchId = message.getId();
                int size = message.getEntries().size();
                if (batchId == -1 || size == 0) {
                    emptyCount++;
                    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
                } else {
                    //Reset the counter to zero
                    emptyCount = 0;
                    printEntry(message.getEntries());
                }
                connector.ack(batchId); // Submit confirmation
                // connector.rollback(batchId); // Processing failed, Roll back data
            }
            System.out.println("已经监听了"+totalEmptyCount+"秒，无任何消息，请重启重试......");
        } finally {
            connector.disconnect();
        }
    }
}

Filter regular expression configured for connector.subscribe in the Java program

try-with-resourcesNo need to manually close anymore

jedisIt closes automatically, so manual closing is not neededfinally

Because bitmap used too much memory when the data volume was too large, hyperloglog evolved from it, and the memory reduction effect is significant

http://antirez.com/news/75

1.04/16384/16384 = 0.0081

public static final String CITY ="city";  

@Autowired  
private RedisTemplate redisTemplate;
public String geoAdd()  
{  
    Map<String, Point> map = new HashMap<>();  
    map.put("天安门",new Point(116.403963,39.915119));  
    map.put("故宫",new Point(116.403414,39.924091));  
    map.put("长城",new Point(116.024067,40.362639));  
  
    redisTemplate.opsForGeo().add(CITY,map);  
  
    return map.toString();  
}  
  
public Point position(String member) {  
    //Get longitude and latitude coordinates  
    List<Point> list = redisTemplate.opsForGeo().position(CITY, member);  
    return list.get(0);  
}  
  
public String hash(String member) {  
    //geohash Generated by algorithm base32 Encoded value  
    List<String> list = redisTemplate.opsForGeo().hash(CITY, member);  
    return list.get(0);  
}  
  
public Distance distance(String member1, String member2) {  
    //Get the distance between two given locations  
    Distance distance = redisTemplate.opsForGeo().distance(CITY, member1, member2,  
            RedisGeoCommands.DistanceUnit.KILOMETERS);  
    return distance;  
}  
public GeoResults radiusByxy() {  
    //Find nearby places by longitude and latitude,Wangfujing location in Beijing 116.418017,39.914402  
    //Metrics.KILOMETERS.getMultiplier()Radius of the circle in kilometers
    Circle circle = new Circle(116.418017, 39.914402, Metrics.KILOMETERS.getMultiplier());  
    // return 50 items  
    RedisGeoCommands.GeoRadiusCommandArgs args = RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs().includeDistance().includeCoordinates().sortDescending().limit(50);  
  
    GeoResults<RedisGeoCommands.GeoLocation<String>> geoResults = redisTemplate.opsForGeo().radius(CITY, circle, args);  
  
    return geoResults;  
}  
public GeoResults radiusByMember() {  
    //find nearby by location  
    return null;  
}

Multiple slots can be combined to indicate whether a data item exists; it exists only when multiple slots are all present

Therefore, after adding data to a Bloom filter, try to minimize deletions

With only one hash function, hash collisions easily occur; multiple hash functions can reduce hash collisions

• Initialize the bitmap

• Add and occupy slots

• Determine whether it exists

After computing the hash, throughhashValueand modulo 2 to the 32nd power, obtain the corresponding index slot

1. ThroughBloomFlterInitAdd existing data as a whitelist into the Bloom filter

2. ThroughCheckUtilsCheck whether new data is in the Bloom filter

3. Obtain the hash value int hashvalues = Math.abs(key.hashCode());

4. Obtain the slot number long v = (long) (hashvalues % Math.pow(2, 32));

5. Set the bit redisTemplate.opsForValue().setBit("whitelistCustomer",v, true);

* Bloom filter whitelist initialization utility class, at the start set part of the data as whitelist,   
* Whitelist business default rule: if the Bloom filter says yes, redis it is very likely yes. 


@Component
public class BloomFilterInit  
{  
    @Resource  
    private RedisTemplate redisTemplate;  
  
    @PostConstruct//Initialize whitelist data,Temporarily commented out to save background printing  
    public void init()  
    {  
        //1 Load whitelist customers into the Bloom filter  
        String key = "customer:12";  
        //2 Compute hashValue,Since there is a possibility of computing a negative number, we take the absolute value  
        int hashValue = Math.abs(key.hashCode());  
        //3 Through hashValue and 2 of the 32 after power, take the remainder to obtain the corresponding index slot  
        long index = (long)(hashValue % Math.pow(2,32));  
        log.info(key+" 对应的坑位index:{}",index);  
        //4 Set redis inside bitmap corresponding type whitelist: whitelistCustomer slot, set this value to 1  
        redisTemplate.opsForValue().setBit("whitelistCustomer",index,true);  
  
    }  
}

public class CheckUtils  
{  
    @Resource  
    private RedisTemplate redisTemplate;  
  
    public boolean checkWithBloomFilter(String checkItem,String key)  
    {  
        int hashValue = Math.abs(key.hashCode());  
        long index = (long)(hashValue % Math.pow(2,32)); 
        ////checkItem is key value 
        boolean existOK = redisTemplate.opsForValue().getBit(checkItem,index);  
        log.info("--->key:"+key+" 对应坑位下标index: "+index+" 是否存在："+existOK);  
  
        return existOK;  
    }  
}

public Customer findCustomerByIdWithBloomFilter (Integer customerId)  
{  
    Customer customer = null;  
    //cache key name  
    String key = CACHA_KEY_CUSTOMER + customerId;  
  
    //Bloom filter check，No is absolutely no, yes is possibly yes  
    //===============================================  
    if(!checkUtils.checkWithBloomFilter("whitelistCustomer",key))  
    {  
        log.info("白名单无此顾客，不可以访问: "+key);  
        return null;    }  
    //===============================================  
  
    //1 Query redis  
    customer = (Customer) redisTemplate.opsForValue().get(key);  
    //redis No, further query mysql  
    if (customer == null) {  
        //2 From mysql found customer  
        customer = customerMapper.selectByPrimaryKey(customerId);  
        // mysql Yes, redis No  
        if (customer != null) {  
            //3 Write the mysql retrieved data into redis，to make the next query able to redis hit.   
            redisTemplate.opsForValue().set(key, customer);  
        }  
    }  
    return customer;  
}

The smaller the misjudgment rate, the more slots generated and the more hash functions used

However, increasing the number of hash functions also increases computational overhead. Usually, a reasonable number of hash functions can reduce computational cost while maintaining a low misjudgment rate

This 10 ten thousand pieces of data are not in the Bloom filter,should all not exist,but due to filter misjudgment may be judged as existing

@Service
@Slf4j
public class GuavaBloomFilterService
{
    //1 define a constant
    public static final int _1W = 10000;
    //2 define our guava Bloom filter, initial capacity
    public static final int SIZE = 100 * _1W;
    //3 misjudgment rate, the smaller it is the fewer misjudgments there are(Think, can it be infinitely small? Would it not be better without false positives?)
    public static double fpp = 0.01;//0.01 0.000000000000001
    //4 Create guava Bloom filter
    private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), SIZE,fpp);


    public void guavaBloomFilter()
    {
        //1 First let bloomFilter add 100W whitelist data
        for (int i = 1; i <= SIZE  ; i++) {
            bloomFilter.put(i);
        }
        //2 deliberately take 10W pieces of data not in the legal range,to demonstrate the false positive rate
        ArrayList<Integer> list = new ArrayList<>(10 * _1W);

        //3 Verify
        //the filter only added SIZE data,deliberately from SIZE+1 data outside to start judging,false positives appear
        for (int i = SIZE+1; i <= SIZE+(10 * _1W) ; i++)
        {
            if(bloomFilter.mightContain(i))
            {
                log.info("被误判了:{}",i);
                list.add(i);
            }
        }
        log.info("误判总数量:{}",list.size());
    }
}

For example, Double Eleven business only runs for a few days, after the time passes it is cleared but then accessed again Right after deletion, other threads may access it again

Principle

Synchronized block

Synchronized method

In order to lock hope to extract the following section

hope to extract this section into a method and turn it into lock

• Lock : Lua script for locking and counting

Check if the lock exists. If it exists, create it, set the count to 1 by default, and set the expiration time If it is determined to exist and belongs to itself, it means reuse. Set the counter to increment by one and set the expiration time

Return 0 if not present, return 1 if present

Optimize to Then rewrite as a Lua script

hincrbyIf it does not exist, it will be created automatically

unlock : Extract this section into a method to become unlock

Check whether the lock exists and belongs to itself, then decrement the counter by one Check if the counter is zero and delete it directly If it does not exist, return directly

call method return 0 , it usually indicates successful execution and returns an integer value, which is equivalent tojavainreturn

The counter decrements to 0, indicating that everything has been unlocked and it can be deleted

@Component  
public class DistributedLockFactory  
{  
    @Autowired  
    private StringRedisTemplate stringRedisTemplate;  
    private String lockName;  
    private String uuid;  
  
    public DistributedLockFactory()  
    {
        this.uuid = IdUtil.simpleUUID();
    }  
  
    public Lock getDistributedLock(String lockType)  
    {
        if(lockType == null) return null;  
  
        if(lockType.equalsIgnoreCase("REDIS")){  
            this.lockName = "zzyyRedisLock";  
            return new RedisDistributedLock(stringRedisTemplate,lockName,uuid);  
        }else if(lockType.equalsIgnoreCase("ZOOKEEPER")){  
            this.lockName = "zzyyZookeeperLockNode";  
            //TODO zookeeper version distributed lock  
            return null;  
        }else if(lockType.equalsIgnoreCase("MYSQL")){  
            //TODO MYSQL version distributed lock  
            return null;  
        }  
  
        return null;  
    }  
}

lock()will call tryLock() tryLock()CalltryLock(long time, TimeUnit unit)

import cn.hutool.core.util.IdUtil;  
import org.springframework.data.redis.core.StringRedisTemplate;  
import org.springframework.data.redis.core.script.DefaultRedisScript;  
import org.springframework.stereotype.Component;  
  
import java.util.Arrays;  
import java.util.Timer;  
import java.util.TimerTask;  
import java.util.concurrent.TimeUnit;  
import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;  


/**  
 * @auther zzyy  
 * @create 2023-01-09 16:41  
 * our self developed redis distributed lock, implemented Lock interface  
 */  
//@Component imported DistributedLockFactory factory pattern, just get it from the factory  
public class RedisDistributedLock implements Lock  
{  
    private StringRedisTemplate stringRedisTemplate;  
  
    private String lockName;//KEYS[1]  
    private String uuidValue;//ARGV[1]  
    private long   expireTime;//ARGV[2]  
  
  
    public RedisDistributedLock(StringRedisTemplate stringRedisTemplate, String lockName, String uuid)  
    {  
        this.stringRedisTemplate = stringRedisTemplate;  
        this.lockName = lockName;  
        this.uuidValue = uuid+":"+Thread.currentThread().getId();  
        this.expireTime = 30L;  
    }  
  
  
    @Override  
    public void lock()  
    {  
        tryLock();  
    }  
    @Override  
    public boolean tryLock()  
    {  
        try {tryLock(-1L,TimeUnit.SECONDS);} catch (InterruptedException e) {e.printStackTrace();}  
        return false;  
    }  
  
    @Override  
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException  
    {  
        if(time == -1L)  
        {  
            String script =  
                    "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then    " +  
                            "redis.call('hincrby',KEYS[1],ARGV[1],1)    " +  
                            "redis.call('expire',KEYS[1],ARGV[2])    " +  
                            "return 1  " +  
                    "else   " +  
                            "return 0 " +  
                    "end";  
            System.out.println("lockName:"+lockName+"\t"+"uuidValue:"+uuidValue);  
            //the execution script is true success, but while in it is false will jump out of the loop, that is, negation is needed  
            while(!stringRedisTemplate.execute(new DefaultRedisScript<>(script,Boolean.class), Arrays.asList(lockName), uuidValue,String.valueOf(expireTime)))  
            {  
                //pause 60 milliseconds  
                try { TimeUnit.MILLISECONDS.sleep(60); } catch (InterruptedException e) { e.printStackTrace(); }  
            }  
            //create a new background scanning program to persist key the current ttl，whether it reaches our specified 1/2 1/3 to implement renewal  
            renewExpire();  
            return true;        }  
        return false;  
    }  
  
  
    //execute the unlock script  
    @Override  
    public void unlock()  
    {  
        System.out.println("unlock(): lockName:"+lockName+"\t"+"uuidValue:"+uuidValue);  
        String script =  
                "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 0 then    " +  
                        "return nil  " +  
                "elseif redis.call('HINCRBY',KEYS[1],ARGV[1],-1) == 0 then    " +  
                        "return redis.call('del',KEYS[1])  " +  
                "else    " +  
                        "return 0 " +  
                "end";  
        // nil = null 1 = true 0 = false the return value has three sets of values  
        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(script, Long.class), Arrays.asList(lockName), uuidValue, String.valueOf(expireTime));  
  
        //if there is no lock it will return null,indicating timeout, the own lock will automatically disappear, and it will not affect other threads creating their own locks (key：value，number）  
        if(null == flag)  
        {  
            throw new RuntimeException("this lock doesn't exists，o(╥﹏╥)o");  
        }  
    }  
	  //automatic renewal
    private void renewExpire()  
  
    {  
        String script =  
                "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 1 then     " +  
                        "return redis.call('expire',KEYS[1],ARGV[2]) " +  
                "else     " +  
                        "return 0 " +  
                "end";  
        //timer is java the timer of  
        new Timer().schedule(new TimerTask()  
        {  
            @Override  
            public void run()  
            {  
                if (stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(lockName), uuidValue, String.valueOf(expireTime)))  
                {  
                    renewExpire();  
                }  
            }  
        },(this.expireTime * 1000)/3);  
    }  
  
  
    //====the following two are temporarily unused, no longer rewritten  
    //no need to consider interruption,just delete it when done  
    @Override  
    public void lockInterruptibly() throws InterruptedException  
    {  
  
    }  
    @Override  
    public Condition newCondition()  
    {  
        return null;  
    }  
}

//V8.0，the completion of the automatic renewal function, a custom background scanning program, if the business logic is not completed within the specified time, it will call the script for adding time and automatic renewal  
public String sale()  
{  
    String retMessage = "";  
  
    Lock redisLock = distributedLockFactory.getDistributedLock("redis");  
    redisLock.lock();  
    try    {  
        //1 query inventory information  
        String result = stringRedisTemplate.opsForValue().get("inventory001");  
        //2 determine whether the inventory is sufficient  
        Integer inventoryNumber = result == null ? 0 : Integer.parseInt(result);  
        //3 deduct inventory, reduce by one each time  
        if(inventoryNumber > 0)  
        {  
            stringRedisTemplate.opsForValue().set("inventory001",String.valueOf(--inventoryNumber));  
            retMessage = "成功卖出一个商品,库存剩余:"+inventoryNumber;  
            System.out.println(retMessage+"\t"+"服务端口号"+port);  
            //pause 120 seconds thread,intentionally, to demonstrate the automatic renewal function......  
            try { TimeUnit.SECONDS.sleep(120); } catch (InterruptedException e) { e.printStackTrace(); }  
  
        }else{  
            retMessage = "商品卖完了,o(╥﹏╥)o";  
        }  
    }finally {  
        redisLock.unlock();  
    }  
    return retMessage+"\t"+"服务端口号"+port;  
}

The second step is to try to acquire the lock on each Redis instance in turn, and if the timeout is exceeded, move directly to the next Redis acquisition. The time consumed by finally trying all Redis instances, minus the time consumed by the first step, is the time taken to acquire the lock

Fault tolerance formula

2x+1

x is the number of failed nodes

1. change pom

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


2. in configuration in redisConfig the configuration in (or the configuration yaml）

@Bean  
public Redisson redisson()  
{  
    Config config = new Config();  
    //add multiple,this is only a demonstration
    config.useSingleServer().setAddress("redis://192.168.111.185:6379").setDatabase(0).setPassword("111111");  
    
  // or read config from file
//config = Config.fromYAML(new File("config-file.yaml")); 

    return (Redisson) Redisson.create(config);  
}

@Autowired  
private StringRedisTemplate stringRedisTemplate;

@Value("${server.port}")  
private String port;

@Autowired
private DistributedLockFactory distributedLockFactory;  

//V9.1,introduce Redisson the recommendation from the official website corresponding to RedLock algorithm implementation class
@Autowired  
private Redisson redisson;  
public String saleByRedisson()  
{  
    String retMessage = "";  
  
    RLock redissonLock = redisson.getLock("zzyyRedisLock");  
    redissonLock.lock();  
  
    try{
        //1 query inventory information
        String result = stringRedisTemplate.opsForValue().get("inventory001");  
        //2 determine whether the inventory is sufficient
        Integer inventoryNumber = result == null ? 0 : Integer.parseInt(result);  
        //3 deduct inventory, decreasing by one each time
        if(inventoryNumber > 0)  
        {  
            stringRedisTemplate.opsForValue().set("inventory001",String.valueOf(--inventoryNumber));  
            retMessage = "成功卖出一个商品,库存剩余:"+inventoryNumber;  
            System.out.println(retMessage+"\t"+"服务端口号"+port);  
        }else{  
            retMessage = "商品卖完了,o(╥﹏╥)o";  
        }  
    }finally {  
        //improvement point, can only delete your own key，cannot delete others  
        if(redissonLock.isLocked() && redissonLock.isHeldByCurrentThread())  
        {  
            redissonLock.unlock();  
        }  
    }  
    return retMessage+"\t"+"服务端口号"+port;  
}

the newly created default 30 seconds

Locking process

scheduleExpriationRenewalRenew the cache

Renewal

Unlock

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


server.port=9090
spring.application.name=redlock


spring.swagger2.enabled=true


spring.redis.database=0
spring.redis.password=
spring.redis.timeout=3000
spring.redis.mode=single
//pooling technology
spring.redis.pool.conn-timeout=3000
spring.redis.pool.so-timeout=3000
spring.redis.pool.size=10

spring.redis.single.address1=192.168.111.185:6381
spring.redis.single.address2=192.168.111.185:6382
spring.redis.single.address3=192.168.111.185:6383