Cet article vous présente principalement l'implémentation et l'analyse du code des verrous distribués dans Redis. J'espère qu'il vous sera utile !
Les poignées de verrouillage distribuées sont utilisées dans les projets de chacun. Elles sont généralement utilisées pour des scénarios de fonctionnement ordonné des données, tels que le remboursement d'une commande (si elle peut être remboursée plusieurs fois). Ou encore, les utilisateurs passent des commandes via plusieurs terminaux. [Recommandations associées : Tutoriel vidéo Redis]
Dépendance Maven
Je l'implémente principalement sur la base de Spring-Boot 2.1.2
+ Jedis
Spring-Boot 2.1.2
+ Jedis
进行实现
<?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 http://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.1.2.RELEASE</version> </parent> <groupId>cn.edu.cqvie</groupId> <artifactId>redis-lock</artifactId> <version>1.0-SNAPSHOT</version> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <java.version>1.8</java.version> <redis.version>2.9.0</redis.version> <spring-test.version>5.0.7</spring-test.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-autoconfigure</artifactId> </dependency> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> </dependency> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>${redis.version}</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-logging</artifactId> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>log4j-over-slf4j</artifactId> </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> </plugin> </plugins> </build> </project>
配置文件
application.properties
配置文件内容如下:
spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.redis.password= spring.redis.timeout=30000 spring.redis.jedis.pool.max-active=8 spring.redis.jedis.pool.min-idle=2 spring.redis.jedis.pool.max-idle=4 logging.level.root=INFO
接口定义
接口定义,对于锁我们核心其实就连个方法 lock
和 unlock
.
public interface RedisLock { long TIMEOUT_MILLIS = 30000; int RETRY_MILLIS = 30000; long SLEEP_MILLIS = 10; boolean tryLock(String key); boolean lock(String key); boolean lock(String key, long expire); boolean lock(String key, long expire, long retryTimes); boolean unlock(String key); }
分布式锁实现
我的实现方式是通过 setnx 方式实现了,如果存在 tryLock
逻辑的话,会通过 自旋
的方式重试
// AbstractRedisLock.java 抽象类 public abstract class AbstractRedisLock implements RedisLock { @Override public boolean lock(String key) { return lock(key, TIMEOUT_MILLIS); } @Override public boolean lock(String key, long expire) { return lock(key, TIMEOUT_MILLIS, RETRY_MILLIS); } } // 具体实现 @Component public class RedisLockImpl extends AbstractRedisLock { private Logger logger = LoggerFactory.getLogger(getClass()); @Autowired private RedisTemplate<String, String> redisTemplate; private ThreadLocal<String> threadLocal = new ThreadLocal<String>(); private static final String UNLOCK_LUA; static { StringBuilder sb = new StringBuilder(); sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] "); sb.append("then "); sb.append(" return redis.call(\"del\",KEYS[1]) "); sb.append("else "); sb.append(" return 0 "); sb.append("end "); UNLOCK_LUA = sb.toString(); } @Override public boolean tryLock(String key) { return tryLock(key, TIMEOUT_MILLIS); } public boolean tryLock(String key, long expire) { try { return !StringUtils.isEmpty(redisTemplate.execute((RedisCallback<String>) connection -> { JedisCommands commands = (JedisCommands) connection.getNativeConnection(); String uuid = UUID.randomUUID().toString(); threadLocal.set(uuid); return commands.set(key, uuid, "NX", "PX", expire); })); } catch (Throwable e) { logger.error("set redis occurred an exception", e); } return false; } @Override public boolean lock(String key, long expire, long retryTimes) { boolean result = tryLock(key, expire); while (!result && retryTimes-- > 0) { try { logger.debug("lock failed, retrying...{}", retryTimes); Thread.sleep(SLEEP_MILLIS); } catch (InterruptedException e) { return false; } result = tryLock(key, expire); } return result; } @Override public boolean unlock(String key) { try { List<String> keys = Collections.singletonList(key); List<String> args = Collections.singletonList(threadLocal.get()); Long result = redisTemplate.execute((RedisCallback<Long>) connection -> { Object nativeConnection = connection.getNativeConnection(); if (nativeConnection instanceof JedisCluster) { return (Long) ((JedisCluster) nativeConnection).eval(UNLOCK_LUA, keys, args); } if (nativeConnection instanceof Jedis) { return (Long) ((Jedis) nativeConnection).eval(UNLOCK_LUA, keys, args); } return 0L; }); return result != null && result > 0; } catch (Throwable e) { logger.error("unlock occurred an exception", e); } return false; } }
测试代码
最后再来看看如何使用吧. (下面是一个模拟秒杀的场景)
@RunWith(SpringRunner.class) @SpringBootTest public class RedisLockImplTest { private Logger logger = LoggerFactory.getLogger(getClass()); @Autowired private RedisLock redisLock; @Autowired private StringRedisTemplate redisTemplate; private ExecutorService executors = Executors.newScheduledThreadPool(8); @Test public void lock() { // 初始化库存 redisTemplate.opsForValue().set("goods-seckill", "10"); List<Future> futureList = new ArrayList<>(); for (int i = 0; i < 100; i++) { futureList.add(executors.submit(this::seckill)); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } // 等待结果,防止主线程退出 futureList.forEach(action -> { try { action.get(); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } }); } public int seckill() { String key = "goods"; try { redisLock.lock(key); int num = Integer.valueOf(Objects.requireNonNull(redisTemplate.opsForValue().get("goods-seckill"))); if (num > 0) { redisTemplate.opsForValue().set("goods-seckill", String.valueOf(--num)); logger.info("秒杀成功,剩余库存:{}", num); } else { logger.error("秒杀失败,剩余库存:{}", num); } return num; } catch (Throwable e) { logger.error("seckill exception", e); } finally { redisLock.unlock(key); } return 0; } }
本文是 Redis 锁的一种简单的实现方式,基于 jedis
rrreee
application.properties
Le contenu du fichier de configuration est le suivant : 🎜rrreee🎜🎜🎜Définition de l'interface🎜🎜🎜🎜Définition de l'interface, pour notre core lock, il y a en fait, une seule méthode lock
et unlock
.🎜rrreee🎜🎜🎜Implémentation du verrouillage distribué🎜🎜🎜🎜Mon implémentation se fait via setnx S'il y a tryLock logique Si c'est le cas, il sera réessayé par <code>spin
🎜rrreee🎜🎜🎜Code de test🎜🎜🎜🎜Voyons enfin comment l'utiliser (Ce qui suit est un scénario de vente flash simulé)🎜rrreee🎜. 🎜 Résumé 🎜🎜🎜Cet article est une implémentation simple du verrouillage Redis, qui implémente une opération de nouvelle tentative de verrouillage basée sur jedis
.
Cependant, il présente encore des inconvénients. Il ne prend pas en charge le renouvellement automatique des verrous, la réentrée des verrous et l'équité (actuellement implémentée via spin, ce qui équivaut à une méthode injuste). 🎜🎜Pour plus de connaissances sur la programmation, veuillez visiter : 🎜Introduction à la programmation🎜 ! ! 🎜Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!