文章目录
分布式锁
synchronized 和 lock 都是 jvm 级别的锁, 只能锁单机的并发, 在集群环境下会失效, 分布式锁是在多机集群下都有效的锁
常用的分布式锁是用 Redis 和 Zookeeper 实现的, redis集群和zookeeper集群下, 加锁时,redis锁的性能会高于zookeeper锁, 因为zookeeper是强一致性, 主节点执行加锁操作会同步到足够多的从节点, 而redis集群则默认不会这么做
大多情况下, redis分布式锁已经足够了
Redis分布式锁
setnx
原子操作, 当某key不存在, 设置该key, 某key存在时, 不设置该key
Spring RedisTemplate 实现
@Component
public class TestBiz {
@Resource
private RedisTemplate<String, Object> redisTemplate;
public Object doBusiness(String mobile) {
String lockKey = "APPLICATION_BUSINESS_SCENE_" + mobile;
String threadId = UUID.randomUUID().toString().replace("-", "");
// 该锁已经基本可用了,但是还存在超时问题,可以设置看门狗线程做锁续期操作(比如1/3个超时时间后,判断锁是否还存在,在的话重新续期为完整超时时间,否则销毁自身)
Boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey, threadId, 1, TimeUnit.MINUTES);
if (null == success || !success) {
throw new RuntimeException("lock failure");
}
try {
// doBusiness
return null;
} finally {
// 判断threadId相同再解锁,是为了防止某线程锁超时自动释放后,该线程执行到解锁代码时,解锁了其他线程加的锁
// 可以使用lua脚本将这两条命令整合到一起
if (threadId.equals(redisTemplate.opsForValue().get(lockKey))) {
redisTemplate.delete(lockKey);
}
}
}
}
other
还有一些奇怪的实现就不推荐了, 可能是受制于当时redis版本, 有些命令暂不支持, 比如set的带nx和timeout的版本
Redisson
Redisson是redis的java客户端工具, 和jedis, lettuce不同的时, redisson更倾向于将jdk的各种并发工具或容器利用redis做成分布式版本
redisson分布式锁
@Bean
public Redisson redisson() {
String[] redisClusterNodeArray = redisClusterNodes.split(",");
for (int i = 0; i < redisClusterNodeArray.length; i++) {
redisClusterNodeArray[i] = "redis://".concat(redisClusterNodeArray[i]);
}
Config config = new Config();
// 一个小时扫描一次集群,判断是否有发生变化,
config.useClusterServers().addNodeAddress(redisClusterNodeArray).setScanInterval(1000 * 60 * 60);
return (Redisson) Redisson.create(config);
}
@Component
public class TestBiz {
@Resource
private Redisson redisson;
public Object doBusiness(String mobile) {
RLock lock = redisson.getLock("APPLICATION_BUSINESS_SCENE_" + mobile);
try {
if (!lock.tryLock(0, 60L, TimeUnit.SECONDS)) {
throw new RuntimeException("lock conflict");
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("lock error");
}
try {
// doBusiness
return null;
} finally {
if (lock.isLocked()) {
lock.unlock();
}
}
}
}
原理
@Resource
private Redisson redisson;
// 通过redisson.getLock()获取一个RedissonObject对象,key 就是lockName
RLock lock = redisson.getLock(key);
boolean success = lock .lock(1L, TimeUnit.MINUTES);
lock .unlock();
boolean success = lock .tryLock(0, 1L, TimeUnit.MINUTES);
lock .unlock();
加锁成功后, 启动看门狗线程, 每超时时间的1/3时给锁续期
// org.redisson.RedissonLock#tryLockInnerAsync
// 没锁时加锁返回空,该锁重入时加1返回空,其他返回锁剩余时间
<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
// 使用传入的释放时间覆盖掉默认的覆盖时间(30s)
internalLockLeaseTime = unit.toMillis(leaseTime);
// 核心lua脚本
// getName返回的就是获取RLock时候的key, 第一个参数是超时时间, 第二个参数是根据线程Id拿到的一个全局唯一id
// 同一个方法加锁,不同线程使用同一个
// 如果大key不存在,即还没有加锁,哈希设置大kay:key,小key:threadId,value:1, 设置过期时间,返回空
// 如果大key小key存在,即已加过锁,值自增,重新设置过期时间,返回空. 可重入锁?
// 如果不是上面两种情况,则返回该锁的剩余过期时间. 其实就是在加锁中时,又有其他线程来加锁了,就返回锁的过期时间
return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
"if (redis.call('exists', KEYS[1]) == 0) then " +
"redis.call('hset', KEYS[1], ARGV[2], 1); " +
"redis.call('pexpire', KEYS[1], ARGV[1]); " +
"return nil; " +
"end; " +
"if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
"redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
"redis.call('pexpire', KEYS[1], ARGV[1]); " +
"return nil; " +
"end; " +
"return redis.call('pttl', KEYS[1]);",
Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
}
上面的方法是Redisson加锁的核心Lua脚本逻辑, 效果同如下的伪代码
使用 hash 结构, 大key是传入的key, 小key是uuid:线程Id, 值是进入次数
if (没有锁) {
加锁返回空
}
if (重入了) {
值自增返回空
}
返回锁剩余时间
能执行到返回剩余时间的都是其他线程来加锁, 拿到剩余时间后, 在while里等待ttl, 重新抢锁
解锁的时候先自减, 减为0的时候删除掉key
RedissonReadWriteLock
分布式读写锁, 可用在读多写少且需要保证原子写的场景下
RedissonReadWriteLock readWriteLock = new RedissonReadWriteLock();
RedissonReadLock readLock = readWriteLock.getReadLock();
readLock.lock();
readLock.unlock();
RedissonWriteLock writeLock = readWriteLock.getWriteLock();
writeLock.lock();
writeLock.unlock();
RedissonMultiLock
把多把常规Redisson分布式锁汇总成一把锁, 同时加成功才算作最终加锁成功, 用于原子操作多个临界资源时, 比如同时对用户的id和mobile加锁, 防止与id单独加锁和mobile单独加锁的两个方法冲突
@Component
public class TestBiz {
@Resource
private Redisson redisson;
public Object doBusiness(String mobile, long id) {
String lockKeyMobile = "APPLICATION_BUSINESS_SCENE_MOBILE_" + mobile;
String lockKeyId = "APPLICATION_BUSINESS_SCENE_ID_" + id;
RLock lock1 = redisson.getLock(lockKeyMobile);
RLock lock2 = redisson.getLock(lockKeyId);
RedissonMultiLock multiLock = new RedissonMultiLock(lock1, lock2);
try {
if (!multiLock.tryLock(0, 60L, TimeUnit.SECONDS)) {
throw new RuntimeException("lock conflict");
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("lock error");
}
try {
// doBusiness
return null;
} finally {
if (multiLock.isLocked()) {
multiLock.unlock();
}
}
}
}
RedissonRedLock
就是redis主节点中有一半以上加锁成功, 才算作最终加锁成功
不推荐使用该方式, 比较复杂, 内部容易出错
@Component
public class TestBiz {
@Resource
private Redisson redisson6379;
@Resource
private Redisson redisson6380;
@Resource
private Redisson redisson6381;
public Object doBusiness(String mobile) {
String lockKey = "APPLICATION_BUSINESS_SCENE_" + mobile;
RLock lock1 = redisson6379.getLock(lockKey);
RLock lock2 = redisson6380.getLock(lockKey);
RLock lock3 = redisson6381.getLock(lockKey);
RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3);
try {
if (!redLock.tryLock(0, 60L, TimeUnit.SECONDS)) {
throw new RuntimeException("lock conflict");
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("lock error");
}
try {
// doBusiness
return null;
} finally {
if (redLock.isLocked()) {
redLock.unlock();
}
}
}
}
性能继续提高?
分段锁, 拆分key, 加上hash手段让一个key拆分到集群的每台机子上, 成倍提升性能
如10节点集群, 库存 key=1000, 分成 key-01=100, key-02=100, …, key-10=100, 10个key分摊到集群的各个节点上
扫一扫
823
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
