Beispielanalyse des Implementierungsprinzips der verteilten Redis-Sperre

Um sicherzustellen, dass verteilte Sperren verfügbar sind, müssen wir zunächst mindestens sicherstellen, dass die Sperrimplementierung gleichzeitig die folgenden vier Bedingungen erfüllt:

1. Es kann immer nur ein Client die Sperre halten.

2. Es wird kein Deadlock auftreten. Selbst wenn ein Client abstürzt, während er die Sperre hält, ohne sie aktiv zu entsperren, ist gewährleistet, dass andere Clients ihn anschließend sperren können.

3. Fehlertolerant. Solange die meisten Redis-Knoten normal laufen, kann der Client sperren und entsperren.

4. Um die Glocke zu lösen, müssen Sie die Glocke binden. Das Sperren und Entsperren muss vom selben Client durchgeführt werden. Der Client selbst kann die von anderen hinzugefügte Sperre nicht entsperren.

Das Folgende ist die Code-Implementierung. Zuerst müssen wir die Open-Source-Komponente Jedis über Maven einführen und den folgenden Code zur Datei pom.xml hinzufügen: Jedis开源组件，在pom.xml文件加入下面的代码：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.1.0</version>
</dependency>

分布式锁实现代码，DistributedLock.java

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Transaction;
import redis.clients.jedis.exceptions.JedisException;
import java.util.List;
import java.util.UUID;
/**
 * @author swadian
 * @date 2022/3/4
 * @Version 1.0
 * @describetion Redis分布式锁原理
 */
public class DistributedLock {
    //redis连接池
    private static JedisPool jedisPool;
    static {
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置最大连接数
        config.setMaxTotal(200);
        // 设置最大空闲数
        config.setMaxIdle(8);
        // 设置最大等待时间
        config.setMaxWaitMillis(1000 * 100);
        // 在borrow一个jedis实例时，是否需要验证，若为true，则所有jedis实例均是可用的
        config.setTestOnBorrow(true);
        jedisPool = new JedisPool(config, "192.168.3.27", 6379, 3000);
    }
    /**
     * 加锁
     * @param lockName       锁的key
     * @param acquireTimeout 获取锁的超时时间
     * @param timeout        锁的超时时间
     * @return 锁标识
     * Redis Setnx（SET if Not eXists） 命令在指定的 key 不存在时，为 key 设置指定的值。
     * 设置成功，返回 1 。 设置失败，返回 0 。
     */
    public String lockWithTimeout(String lockName, long acquireTimeout, long timeout) {
        Jedis jedis = null;
        String retIdentifier = null;
        try {
            // 获取连接
            jedis = jedisPool.getResource();
            // value值->随机生成一个String
            String identifier = UUID.randomUUID().toString();
            // key值->即锁名
            String lockKey = "lock:" + lockName;
            // 超时时间->上锁后超过此时间则自动释放锁 毫秒转成->秒
            int lockExpire = (int) (timeout / 1000);
            // 获取锁的超时时间->超过这个时间则放弃获取锁
            long end = System.currentTimeMillis() + acquireTimeout;
            while (System.currentTimeMillis() < end) { //在获取锁时间内
                if (jedis.setnx(lockKey, identifier) == 1) {//关键:设置锁
                    jedis.expire(lockKey, lockExpire);
                    // 返回value值，用于释放锁时间确认
                    retIdentifier = identifier;
                    return retIdentifier;
                }
                // ttl以秒为单位返回 key 的剩余过期时间，返回-1代表key没有设置超时时间，为key设置一个超时时间
                if (jedis.ttl(lockKey) == -1) {
                    jedis.expire(lockKey, lockExpire);
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        } catch (JedisException e) {
            e.printStackTrace();
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return retIdentifier;
    }
    /**
     * 释放锁
     * @param lockName   锁的key
     * @param identifier 释放锁的标识
     * @return
     */
    public boolean releaseLock(String lockName, String identifier) {
        Jedis jedis = null;
        String lockKey = "lock:" + lockName;
        boolean retFlag = false;
        try {
            jedis = jedisPool.getResource();
            while (true) {
                // 监视lock，准备开始redis事务
                jedis.watch(lockKey);
                // 通过前面返回的value值判断是不是该锁，若是该锁，则删除，释放锁
                if (identifier.equals(jedis.get(lockKey))) {
                    Transaction transaction = jedis.multi();//开启redis事务
                    transaction.del(lockKey);
                    List<Object> results = transaction.exec();//提交redis事务
                    if (results == null) {//提交失败
                        continue;//继续循环
                    }
                    retFlag = true;//提交成功
                }
                jedis.unwatch();//解除监控
                break;
            }
        } catch (JedisException e) {
            e.printStackTrace();
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return retFlag;
    }
}

为了验证它，我们创建SkillService.java业务类

import lombok.extern.slf4j.Slf4j;
@Slf4j
public class SkillService {
    final DistributedLock lock = new DistributedLock();
    public static final String LOCK_KEY = "lock_resource";
    int n = 500;
    /**
     * 线程业务方法
     */
    public void seckill() {
        // 返回锁的value值，供释放锁时候进行判断
        String identifier = lock.lockWithTimeout(LOCK_KEY, 5000, 1000);
        log.info("线程:"+Thread.currentThread().getName() + "获得了锁");
        log.info("剩余数量:{}",--n);
        lock.releaseLock(LOCK_KEY, identifier);
    }
}

如果找不到@Slf4j日志，在pom.xml

<!--@Slf4j日志依赖组件-->
  <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
</dependency>

Distributed Lock-Implementierungscode, DistributedLock.java

/**
 * @author swadian
 * @date 2022/3/4
 * @Version 1.0
 */
public class TestLock {
    public static void main(String[] args) {
        SkillService service = new SkillService();
        for (int i = 10; i < 60; i++) { //开50个线程
            SkillThread skillThread = new SkillThread(service, "skillThread->" + i);
            skillThread.start();
        }
    }
}
class SkillThread extends Thread {
    private SkillService skillService;
    public SkillThread(SkillService skillService, String skillThreadName) {
        super(skillThreadName);
        this.skillService = skillService;
    }
    @Override
    public void run() {
        skillService.seckill();
    }
}

Um es zu überprüfen, erstellen wir die Business-Klasse SkillService.java

@Slf4j
public class SkillService {
    final DistributedLock lock = new DistributedLock();
    public static final String LOCK_KEY = "lock_resource";
    int n = 500;
    /**
     * 线程业务方法
     */
    public void seckill() {
        // 返回锁的value值，供释放锁时候进行判断
        //String identifier = lock.lockWithTimeout(LOCK_KEY, 5000, 1000);
        log.info("线程:"+Thread.currentThread().getName() + "获得了锁");
        log.info("剩余数量:{}",--n);
        //lock.releaseLock(LOCK_KEY, identifier);
    }
}

Wenn das @Slf4j-Protokoll nicht gefunden werden kann, fügen Sie den folgenden Code zur pom.xml Datei: <p>rrreee<img src="/static/imghw/default1.png" data-src="https://img.php.cn/upload/article/000/887/227/168508915640755.jpg" class="lazy" alt="Beispielanalyse des Implementierungsprinzips der verteilten Redis-Sperre">Eine bearbeiten Die Testklasse TestLock.java</p>rrreee<p>Die Testergebnisse zeigen, dass die verbleibenden Zahlen nach dem Sperren alle sequentiell sind, 499.498.497 ... </p> <p></p> <p><img src="/static/imghw/default1.png" data-src="https://img.php.cn/upload/article/000/887/227/168508915668378.png" class="lazy" alt="Beispielanalyse des Implementierungsprinzips der verteilten Redis-Sperre"> Wir ändern die Geschäftsklasse SkillService.java und kommentieren Sie die Sperrlogik aus</p>rrreee🎜Re Nachdem Sie den Test ausgeführt und die Sperrlogik auskommentiert haben, sind die verbleibenden Zahlen alle außer Betrieb, 472.454.452...🎜🎜🎜🎜

Das obige ist der detaillierte Inhalt vonBeispielanalyse des Implementierungsprinzips der verteilten Redis-Sperre. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!