资讯专栏INFORMATION COLUMN

自定义注解@RedisLock分布式锁用法及原理

oujie / 3307人阅读

摘要:前言最近开发公司的项目,遇到了分布式的场景,即,同一条数据可能被多台服务器或者说多个线程同时修改,此时可能会出现分布式事务的问题,随即封装了分布式锁的注解。

</>复制代码

  1. 前言

最近开发公司的项目,遇到了分布式的场景,即,同一条数据可能被多台服务器或者说多个线程同时修改,此时可能会出现分布式事务的问题,随即封装了redis分布式锁的注解。

</>复制代码

  1. 场景分析

前提:我的银行卡有0元钱,现在有A,B两个人,想分别给我转10元钱
分析:
假如A,B通过读数据库,同时发现我的余额是0,这时,
线程A,会给我设置:
余额 = 10 + 0
线程B,会给我设置:
余额 = 10 + 0

最后,我的卡上收到了两个人的转账,但是最后金额居然只有10元!!这是怎么回事?
其实原因就在于多个线程,对一条数据同时进行了操作。如果我们可以设置一下,在修改的方法上面加一个锁,每次修改之前,(A)先拿到这个锁,再去做修改方法,此时,其他(B)线程想要修改的时候,看到锁已经不再,需要等待锁释放,然后再去执行,就保证了A,B先后依此执行,数据依此累加就没问题了。

</>复制代码

  1. 解决办法

基于代码的可移植性,我将分布式锁做成了注解,大家如果有需要,可以直接将jar包拿过去做相应的修改即可,jar包下载地址(链接:https://pan.baidu.com/s/1hBn-...
提取码:1msl):

注解使用说明:
1.在需要添加分布式锁的方法上面加上@RedisLock
如果key不添加,则默认锁方法第一个参数param的id字段,如果需要指定锁某个字段,则@RedisLock(key = "code")
2.如果方法没有参数,则不可使用RedisLock锁

</>复制代码

  1. @RedisLock
  2. public void updateData( Data param){
  3. }

下面详细分析一下封装的源码:

先看一下项目结构(总共就4个类):

</>复制代码

  1. //RedisLock注解类:没什么好解释的
  2. /**
  3. * Created by liuliang on 2018/10/15.
  4. */
  5. @Target({ElementType.METHOD})
  6. @Retention(RetentionPolicy.RUNTIME)
  7. public @interface RedisLock {
  8. //被锁的数据的id
  9. String key() default "";
  10. //唤醒时间
  11. long acquireTimeout() default 6000L;
  12. //超时时间
  13. long timeout() default 6000L;
  14. }

</>复制代码

  1. //----------------------类分割线---------------------

</>复制代码

  1. //RedisService 一个简单的操作redis的类,封装了加锁和释放锁的方法
  2. /**
  3. * Created by liuliang on 2018/10/15.
  4. */
  5. @Service
  6. public class RedisService {
  7. @Autowired
  8. StringRedisTemplate stringRedisTemplate;
  9. @Resource(name = "stringRedisTemplate")
  10. @Autowired
  11. ValueOperations valOpsStr;
  12. @Autowired
  13. RedisTemplate redisTemplate;
  14. @Resource(name = "redisTemplate")
  15. ValueOperations valOpsObj;
  16. public String getStr(String key) {
  17. return stringRedisTemplate.opsForValue().get(key);//获取对应key的value
  18. // return valOpsStr.get(key);
  19. }
  20. public void setStr(String key, String val) {
  21. stringRedisTemplate.opsForValue().set(key,val,1800, TimeUnit.SECONDS);
  22. // valOpsStr.set(key, val);
  23. }
  24. public void del(String key) {
  25. stringRedisTemplate.delete(key);
  26. }
  27. /**
  28. * 根据指定o获取Object
  29. *
  30. * @param o
  31. * @return
  32. */
  33. public Object getObj(Object o) {
  34. return valOpsObj.get(o);
  35. }
  36. /**
  37. * * 设置obj缓存
  38. * * @param o1
  39. * * @param o2
  40. *
  41. */
  42. public void setObj(Object o1, Object o2) {
  43. valOpsObj.set(o1, o2);
  44. }
  45. /**
  46. * 删除Obj缓存
  47. *
  48. * @param o
  49. */
  50. public void delObj(Object o) {
  51. redisTemplate.delete(o);
  52. }
  53. private static JedisPool pool = null;
  54. static {
  55. JedisPoolConfig config = new JedisPoolConfig();
  56. // 设置最大连接数
  57. config.setMaxTotal(200);
  58. // 设置最大空闲数
  59. config.setMaxIdle(8);
  60. // 设置最大等待时间
  61. config.setMaxWaitMillis(1000 * 100);
  62. // 在borrow一个jedis实例时,是否需要验证,若为true,则所有jedis实例均是可用的
  63. config.setTestOnBorrow(true);
  64. pool = new JedisPool(config, "127.0.0.1", 6379, 3000);
  65. }
  66. DistributedLock lock = new DistributedLock(pool);
  67. /**
  68. * redis分布式加锁
  69. * @param objectId
  70. * @param acquireTimeout
  71. * @param timeout
  72. */
  73. public String redisLock(String objectId,Long acquireTimeout, Long timeout) {
  74. // 对key为id加锁, 返回锁的value值,供释放锁时候进行判断
  75. String lockValue = lock.lockWithTimeout(objectId, acquireTimeout, timeout);
  76. System.out.println(Thread.currentThread().getName() + "获得了锁");
  77. return lockValue;
  78. }
  79. /**
  80. * 释放redis分布式锁
  81. * @param objectId
  82. * @param lockValue
  83. */
  84. public Boolean releaseLock(String objectId,String lockValue){
  85. boolean b = lock.releaseLock(objectId, lockValue);
  86. System.out.println(Thread.currentThread().getName() + "释放了锁");
  87. return b;
  88. }

</>复制代码

  1. //----------------------类分割线---------------------

</>复制代码

  1. /**
  2. * Created by liuliang on 2018/10/15.
  3. *
  4. * 分布式锁的主要类,主要方法就是加锁和释放锁
  5. *具体的逻辑在代码注释里面写的很清楚了
  6. */
  7. @Slf4j
  8. public class DistributedLock {
  9. private final JedisPool jedisPool;
  10. public DistributedLock(JedisPool jedisPool) {
  11. this.jedisPool = jedisPool;
  12. }
  13. /**
  14. * 加锁
  15. * @param locaName 锁的key
  16. * @param acquireTimeout 获取超时时间
  17. * @param timeout 锁的超时时间
  18. * @return 锁标识
  19. */
  20. public String lockWithTimeout(String locaName,
  21. long acquireTimeout, long timeout) {
  22. Jedis conn = null;
  23. String retIdentifier = null;
  24. try {
  25. // 获取连接
  26. conn = jedisPool.getResource();
  27. // 随机生成一个value
  28. String identifier = UUID.randomUUID().toString();
  29. // 锁名,即key值
  30. String lockKey = "lock:" + locaName;
  31. // 超时时间,上锁后超过此时间则自动释放锁
  32. int lockExpire = (int)(timeout / 1000);
  33. // 获取锁的超时时间,超过这个时间则放弃获取锁
  34. long end = System.currentTimeMillis() + acquireTimeout;
  35. while (System.currentTimeMillis() < end) {
  36. log.info("lock...lock...");
  37. if (conn.setnx(lockKey, identifier) == 1) {
  38. log.info("==============lock success!=============");
  39. conn.expire(lockKey, lockExpire);
  40. // 返回value值,用于释放锁时间确认
  41. retIdentifier = identifier;
  42. return retIdentifier;
  43. }
  44. // 返回-1代表key没有设置超时时间,为key设置一个超时时间
  45. if (conn.ttl(lockKey) == -1) {
  46. conn.expire(lockKey, lockExpire);
  47. }
  48. try {
  49. //这里sleep 10ms是为了防止线程饥饿,各位可以思考一下为什么
  50. Thread.sleep(10);
  51. } catch (InterruptedException e) {
  52. Thread.currentThread().interrupt();
  53. }
  54. }
  55. } catch (JedisException e) {
  56. e.printStackTrace();
  57. } finally {
  58. if (conn != null) {
  59. conn.close();
  60. }
  61. }
  62. return retIdentifier;
  63. }
  64. /**
  65. * 释放锁
  66. * @param lockName 锁的key
  67. * @param identifier 释放锁的标识
  68. * @return
  69. */
  70. public boolean releaseLock(String lockName, String identifier) {
  71. Jedis conn = null;
  72. String lockKey = "lock:" + lockName;
  73. boolean retFlag = false;
  74. try {
  75. conn = jedisPool.getResource();
  76. while (true) {
  77. // 监视lock,准备开始事务
  78. conn.watch(lockKey);
  79. //避免空指针
  80. String lockKeyValue = conn.get(lockKey)==null?"":conn.get(lockKey);
  81. // 通过前面返回的value值判断是不是该锁,若是该锁,则删除,释放锁
  82. if (lockKeyValue.equals(identifier)) {
  83. Transaction transaction = conn.multi();
  84. transaction.del(lockKey);
  85. List results = transaction.exec();
  86. if (results == null) {
  87. continue;
  88. }
  89. log.info("==============unlock success!=============");
  90. retFlag = true;
  91. }
  92. conn.unwatch();
  93. break;
  94. }
  95. } catch (JedisException e) {
  96. e.printStackTrace();
  97. } finally {
  98. if (conn != null) {
  99. conn.close();
  100. }
  101. }
  102. return retFlag;
  103. }

</>复制代码

  1. //----------------------类分割线---------------------

</>复制代码

  1. /**
  2. * Created by liuliang on 2018/10/16.
  3. 这是一个拦截器,我们指定拦截RedisLock注解
  4. */
  5. @Aspect
  6. @Component
  7. @Slf4j
  8. public class RedisLockAop {
  9. ThreadLocal beginTime = new ThreadLocal<>();
  10. ThreadLocal objectId = new ThreadLocal<>();
  11. ThreadLocal lockValue = new ThreadLocal<>();
  12. @Autowired
  13. private RedisService redisService;
  14. @Pointcut("@annotation(redisLock)")
  15. public void serviceStatistics(RedisLock redisLock) {
  16. }
  17. @Before("serviceStatistics(redisLock)")
  18. public void doBefore(JoinPoint joinPoint, RedisLock redisLock) {
  19. // 记录请求到达时间
  20. beginTime.set(System.currentTimeMillis());
  21. //注解所在方法名
  22. String methodName = joinPoint.getSignature().getName();
  23. //注解所在类
  24. String className = joinPoint.getSignature().getDeclaringTypeName();
  25. //方法上的参数
  26. Object[] args = joinPoint.getArgs();
  27. String key = redisLock.key();
  28. if(ObjectUtils.isNullOrEmpty(args)){
  29. //方法的参数是空,生成永远不重复的uuid,相当于不做控制
  30. key = methodName + UUID.randomUUID().toString();
  31. }else {
  32. //取第一个参数指定字段,若没有指定,则取id字段
  33. Object arg = args[0];
  34. log.info("arg:"+arg.toString());
  35. Map map = getKeyAndValue(arg);
  36. Object o = map.get(StringUtils.isEmpty(key) ? "id" : key);
  37. if(ObjectUtils.isNullOrEmpty(o)){
  38. //自定义异常,可以换成自己项目的异常
  39. throw new MallException(RespCode.REDIS_LOCK_KEY_NULL);
  40. }
  41. key = o.toString();
  42. }
  43. log.info("线程:"+Thread.currentThread().getName() + ", 已进入方法:"+className+"."+methodName);
  44. // objectId.set(StringUtils.isEmpty(redisLock.key()) ? UserUtils.getCurrentUser().getId() : redisLock.key());
  45. objectId.set(key);
  46. String lock = redisService.redisLock(objectId.get(), redisLock.acquireTimeout(), redisLock.timeout());
  47. lockValue.set(lock);
  48. log.info("objectId:"+objectId.get()+",lockValue:"+lock +",已经加锁!");
  49. }
  50. @After("serviceStatistics(redisLock)")
  51. public void doAfter(JoinPoint joinPoint,RedisLock redisLock) {
  52. String methodName = joinPoint.getSignature().getName();
  53. String className = joinPoint.getSignature().getDeclaringTypeName();
  54. redisService.releaseLock(objectId.get(),lockValue.get());
  55. log.info("objectId:"+objectId.get()+",lockValue:"+lockValue.get() +",已经解锁!");
  56. log.info("线程:"+Thread.currentThread().getName() + ", 已退出方法:"+className+"."+methodName+",耗时:"+(System.currentTimeMillis() - beginTime.get() +" 毫秒!"));
  57. }
  58. //这是一个Object转mapd的方法
  59. public static Map getKeyAndValue(Object obj) {
  60. Map map = new HashMap();
  61. // 得到类对象
  62. Class userCla = (Class) obj.getClass();
  63. /* 得到类中的所有属性集合 */
  64. Field[] fs = userCla.getDeclaredFields();
  65. for (int i = 0; i < fs.length; i++) {
  66. Field f = fs[i];
  67. f.setAccessible(true); // 设置些属性是可以访问的
  68. Object val = new Object();
  69. try {
  70. val = f.get(obj);
  71. // 得到此属性的值
  72. map.put(f.getName(), val);// 设置键值
  73. } catch (IllegalArgumentException e) {
  74. e.printStackTrace();
  75. } catch (IllegalAccessException e) {
  76. e.printStackTrace();
  77. }
  78. /*
  79. * String type = f.getType().toString();//得到此属性的类型 if
  80. * (type.endsWith("String")) {
  81. * System.out.println(f.getType()+"
  82. String"); f.set(obj,"12") ;
  83. * //给属性设值 }else if(type.endsWith("int") ||
  84. * type.endsWith("Integer")){
  85. * System.out.println(f.getType()+"
  86. int"); f.set(obj,12) ; //给属性设值
  87. * }else{ System.out.println(f.getType()+"
  88. "); }
  89. */
  90. }
  91. System.out.println("单个对象的所有键值==反射==" + map.toString());
  92. return map;
  93. }

}

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/71742.html

相关文章

  • Redis详解 - SpringBoot整合Redis,RedisTemplate和注解两种方式的使

    摘要:和注解的方法返回值要一致删除缓存在需要删除缓存的方法上加注解,执行完这个方法之后会将中对应的记录删除。代表返回值,意思是当返回码不等于时不缓存,也就是等于时才缓存。返回值特定值如果被设置了如果没有被设置例子自动将对应到并且返回原来对应的。 本文主要讲 Redis 的使用,如何与 SpringBoot 项目整合,如何使用注解方式和 RedisTemplate 方式实现缓存。最后会给一个用...

    SexySix 评论0 收藏0
  • 基于 Redis 的布式

    摘要:首先谈到分布式锁自然也就联想到分布式应用。如基于的唯一索引。基于的临时有序节点。这里主要基于进行讨论。该命令可以保证的原子性。所以最好的方式是在每次解锁时都需要判断锁是否是自己的。总结至此一个基于的分布式锁完成,但是依然有些问题。 showImg(https://segmentfault.com/img/remote/1460000014128437?w=2048&h=1365); 前...

    fasss 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<