当多线程执行某一业务时（特别是对数据的更新、新增）等操作,可能就会出现多个线程对同一条数据进行修改。其最终的结果一
定与你期望的结果“不太一样”，这就与需要一把锁来控制线程排排队了 – java内部为我们提供了解决方案，可以使用synchronized
或Lock等方式来实现。
　　但是在生产过程中，因为性能的关系，多数公司都会采用多台服务器来搭建”分布式”。一条请求过来之后，不一定会打到哪台服务
器上，这就保证不了多台服务器的某一”关键业务”同一时间只会有一条线程进行执行。这时就需要一个“媒介”来充当”锁”这个角色,这
个“媒介”需要满足一些特性才能胜任这个工作：
（1）各个服务器都可以对其进行获取和操作（基于数据库的实现方式）；
（2）高性能的获取和释放锁；
（3）具备非阻塞锁特性，如果获取不到锁则立即返回失败；
（4）具备锁等待的特性，即没有获取到锁将继续等待获取锁；
（5）具有锁失效机制，防止死锁；
（6）具备可重入特性；

　　高性能、失效时间、可重入、非阻塞等特性，Redis都能满足，所以基于Redis实现是解决分布式锁的一种方式。基于Redis的分布式
锁的实现思想：
  A、加锁
    1、计算开始时间，防止一直获取不到锁而死循环；
    2、根据系统名称：业务名称：主键ID来创建一个分布式锁的key；
    3、循环获取分布式锁（尝试时间=当前时间-开始时间<5000毫秒）；
    4、使用setnx方法获取分布式锁（key,value – 当前系统时间+”$TRUE”，失效时间 – 10毫秒）；
    5、如果设置成功则获取分布式锁成功，返回true；
    6、如果获取失败则睡5毫秒，继续尝试，直到过了时间；
    7、如果时间之内没有获取到分布式所，则返回失败；
  B、解锁
    1、根据系统号，业务名称，主键拼接分布式锁的key；
    2、根据key获取到真实的key（使用keys方法）；
    3、判断真实的key是否为存在，是否唯一，如果否则为空；
    4、如果key唯一则进行删除；
  栗子：

  1. /**
  2.  * Jedis的工具类.
  3.  */
  4. public class JedisUtil {
  5.     private static final Logger LOG = LoggerFactory.getLogger(JedisUtil.class);
  6.     private static Map<String, JedisUtil> uniqueInstance = new HashMap();
  7.     private JedisPool jedisPool;
  8.     private static JedisUtil jedisUtil = null;
  10.     public JedisUtil() {
  11.         super();
  12.     }
  14.     /**
  15.      * 选择需要链接哪个库
  16.      * @param serverName
  17.      */
  18.     public JedisUtil(String serverName) {
  19.         if (StringUtils.isBlank(serverName)) {
  20.             throw new RuntimeException("请指定Redis主或从库!");
  21.         } else {
  22.             //实际使用需从配置文件中获取
  23.             String ip = "127.0.0.1";
  24.             Integer port = 6379;
  25.             String pwd = "test";
  26.             //仅仅是测试用
  27.             String redisPoolMaxActive = "30";
  28.             if ("master".equals(serverName)) {
  29.                 //链接到主库
  30.                 this.initialPool(ip, port, pwd, redisPoolMaxActive);
  31.             }else{
  32.                 //可以链接为别的Redis库
  33.             }
  34.         }
  35.     }
  37.     /**
  38.      * 初始化jedisPool
  39.      * @param ip
  40.      * @param port
  41.      * @param pwd
  42.      * @param redisPoolMaxActive
  43.      */
  44.     private void initialPool(String ip, int port, String pwd, String redisPoolMaxActive) {
  45.         JedisPoolConfig config = new JedisPoolConfig();
  46.         //最大连接数，默认8个
  47.         config.setMaxTotal(256);
  48.         //最大空闲连接数，默认8个
  49.         config.setMaxIdle(256);
  50.         if (StringUtils.isNotBlank(redisPoolMaxActive)) {
  51.             Integer redisPoolMaxActiveInt = Integer.valueOf(Integer.parseInt(redisPoolMaxActive));
  52.             if (redisPoolMaxActiveInt.intValue() > 512) {
  53.                 redisPoolMaxActiveInt = Integer.valueOf(512);
  54.             }
  56.             config.setMaxTotal(redisPoolMaxActiveInt.intValue());
  57.             config.setMaxIdle(redisPoolMaxActiveInt.intValue());
  58.         }
  59.         //获取连接时的最大等待毫秒数
  60.         config.setMaxWaitMillis(1000L);
  61.         //在获取连接的时候检查有效性,默认false
  62.         config.setTestOnBorrow(true);
  63.         config.setTestOnReturn(true);
  64.         //在空闲时检查有效性,默认false
  65.         config.setTestWhileIdle(true);
  66.         //每次逐出检查时 逐出的最大数目。如果为负数就是: 1/abs(n), 默认3
  67.         config.setNumTestsPerEvictionRun(-1);
  68.         //逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
  69.         config.setTimeBetweenEvictionRunsMillis(30000L);
  70.         //逐出连接的最小空闲时间，默认1800000毫秒(30分钟)
  71.         config.setMinEvictableIdleTimeMillis(720000L);
  72.         //对象空闲多久后逐出,当空闲时间>该值且空闲连接 > 最大空闲数时直接逐出,不再根据MinEvictableIdleTimeMillis判断 (默认逐出策略)
  73.         config.setSoftMinEvictableIdleTimeMillis(360000L);
  74.         this.jedisPool = new JedisPool(config, ip, port, 2000, pwd);
  75.         LogUtils.info(LOG, "jedisPool init finish", new Object[]{"jedisPool", this.jedisPool});
  76.     }
  78.     /**
  79.      * 单例获取jedisPool
  80.      * @param serverName Redis库的名称
  81.      * @return
  82.      */
  83.     public static JedisUtil getInstance(String serverName) {
  84.         jedisUtil = (JedisUtil)uniqueInstance.get(serverName);
  85.         if(jedisUtil == null) {
  86.             Class var1 = JedisUtil.class;
  87.             synchronized(JedisUtil.class) {
  88.                 jedisUtil = (JedisUtil)uniqueInstance.get(serverName);
  89.                 if(jedisUtil == null) {
  90.                     jedisUtil = new JedisUtil(serverName);
  91.                     uniqueInstance.put(serverName, jedisUtil);
  92.                 }
  93.             }
  94.         }
  95.         return jedisUtil;
  96.     }
  98.     public Long setnx(String key, String value, int expireTime, int dbIndex) {
  99.         Jedis jedis = null;
  101.         Long var1;
  102.         try {
  103.             jedis = this.jedisPool.getResource();
  104.             jedis.select(dbIndex);
  105.             Long ret = jedis.setnx(key, value);
  106.             if(ret.longValue() == 1L && expireTime > 0) {
  107.                 jedis.expire(key, expireTime);
  108.             }
  110.             var1 = ret;
  111.         } catch (Exception var11) {
  112.             LogUtils.error(LOG, "redis setnx error. ", var11, new Object[0]);
  113.             throw var11;
  114.         } finally {
  115.             if(jedis != null) {
  116.                 jedis.close();
  117.             }
  119.         }
  121.         return var1;
  122.     }
  124.     /**
  125.      * 查找key
  126.      * @param sKey
  127.      * @param index
  128.      * @return
  129.      */
  130.     public Set<String> key(String sKey, int index) {
  131.         Jedis jedis = null;
  133.         Set var2;
  134.         try {
  135.             jedis = this.jedisPool.getResource();
  136.             jedis.select(index);
  137.             var2 = jedis.keys(sKey);
  138.         } catch (Exception var8) {
  139.             LogUtils.error(LOG, "redis key error. ", var8, new Object[0]);
  140.             throw var8;
  141.         } finally {
  142.             if(jedis != null) {
  143.                 jedis.close();
  144.             }
  146.         }
  148.         return var2;
  149.     }
  151.     /**
  152.      * 删除key
  153.      * @param sKey
  154.      * @param index
  155.      * @return
  156.      */
  157.     public Long del(String sKey, int index) {
  158.         Jedis jedis = null;
  160.         Long var3;
  161.         try {
  162.             jedis = this.jedisPool.getResource();
  163.             jedis.select(index);
  164.             var3 = jedis.del(sKey);
  165.         } catch (Exception var8) {
  166.             LogUtils.error(LOG, "redis del error. ", var8, new Object[0]);
  167.             throw var8;
  168.         } finally {
  169.             if(jedis != null) {
  170.                 jedis.close();
  171.             }
  173.         }
  175.         return var3;
  176.     }
  177. }

  分布式锁的工具类：

  1. public class LockRedisService {
  2.     private static final Logger LOG = LoggerFactory.getLogger(LockRedisService.class);private static final Integer EXPIRE_SECOND = Integer.valueOf(10);public LockRedisService() {
  3.     }
  5.     /**
  6.      * 尝试获取分布式锁
  7.      * @param systemName 系统名称
  8.      * @param business   业务名称
  9.      * @param keyfix     主键
  10.      * @return
  11.      */
  12.     public static Boolean tryLock(String systemName, String business, String keyfix) {
  13.         long start = System.currentTimeMillis();
  14.         String key = String.format("lock:%s:%s:%s", new Object[]{systemName, business, keyfix});
  15.         LogUtils.info(LOG, "尝试获取分布式锁", new Object[]{"key", key});
  17.         do {
  18.             try {
  19.                 long ret = JedisUtil.getInstance("master").setnx(key, System.currentTimeMillis() + "$TRUE", EXPIRE_SECOND, 1).longValue();
  20.                 if(ret == 1L) {
  21.                     LogUtils.info(LOG, "成功获得分布式锁", new Object[]{"key", key});
  22.                     return Boolean.TRUE;
  23.                 }
  25.                 Thread.sleep(5L);
  26.             } catch (Exception var8) {
  27.                 LogUtils.error(LOG, "获取锁失败", var8, new Object[0]);
  28.             }
  29.         } while(System.currentTimeMillis() - start < 5000L);
  31.         LogUtils.warn(LOG, "获取分布式锁失败", new Object[]{"key", key});
  32.         return Boolean.FALSE;
  33.     }
  35.     /**
  36.      * 解锁
  37.      * @param systemName 系统名称
  38.      * @param business   业务名称
  39.      * @param keyfix     主键
  40.      * @return
  41.      */
  42.     public static Boolean unlock(String systemName, String business, String keyfix) {
  43.         String key = String.format("lock:%s:%s:%s", new Object[]{systemName, business, keyfix});
  45.         try {
  46.             //1为使用哪个Redis库，正常应该写为枚举类
  47.             Set<String> realKeySet = JedisUtil.getInstance("master").key(key,1);
  48.             if(CollectionUtils.isEmpty(realKeySet)) {
  49.                 return null;
  50.             } else if(realKeySet.size() > 1) {
  51.                 LogUtils.warn(LOG, "lock key 通配符存在多个", new Object[]{"key", key});
  52.                 return null;
  53.             } else {
  54.                 String realKey = (String)realKeySet.iterator().next();
  55.                 JedisUtil.getInstance("master").del(realKey, 1);
  56.             }
  57.         } catch (Exception var5) {
  58.             LogUtils.error(LOG, "解锁失败", var5, new Object[0]);
  59.         }
  61.         LogUtils.info(LOG, "解锁成功", new Object[]{"key", key});
  62.         return Boolean.valueOf(true);
  63.     }
  64. }

  测试类：

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         //获取cpu的核心数
  4.         int count = Runtime.getRuntime().availableProcessors();
  5.         //创建线程池
  6.         ThreadPoolExecutor threadPool = new ThreadPoolExecutor(count, count * 10,
  7.                 60L, TimeUnit.MILLISECONDS,
  8.                 new LinkedBlockingQueue<>(40960), new ThreadPoolExecutor.AbortPolicy());
  9.         //多线程执行业务
  10.         threadPool.execute(()->{
  11.             String bussiness = "测试分布式锁";
  12.             String key = "TestLock:" + 123;
  13.             //尝试获取分布式锁
  14.             if (LockRedisService.tryLock("测试系统", bussiness, key)) {
  15.                 System.out.println("---获取分布式锁成功---");
  16.                 try {
  17.                     //可能会抛出异常
  18.                     System.out.println("执行逻辑");
  19.                 }catch (Exception e){
  20.                     System.out.println("执行逻辑错误: "+e);
  21.                 }finally {
  22.                     //执行完毕后解锁
  23.                     LockRedisService.unlock("测试系统", bussiness, key);
  24.                 }
  25.             }else {
  26.                 System.out.println("获取分布式锁失败");
  27.             }
  28.         });
  29.     }
  30. }

 

版权声明：本文为0813lichenyu原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/0813lichenyu/p/10376631.html