幂等性问题以及解决方案

#此SQL无论执行多少次，虽然结果有可能出现不同，都不会对数据产生改变，具备幂等性。
 select * from table where id=1 
 
 #此SQL如果id或name有唯一性约束，多次操作只允许插入一条记录，则具备幂等性。如果不是，则不具备幂等性，多次操作会产生多条数据。
 insert into table(id,name) values(1,'heima')
 
 #此SQL无论执行多少次，对数据产生的影响都是相同的。具备幂等性。
 update table set score=100 where id = 1 
 
 #此SQL涉及到了计算，每次操作对数据都会产生影响。不具备幂等性。
 update table set score=50+score where id = 1 
 
 #此SQL多次操作，产生的结果相同，具备幂等性
 delete from table where id = 1 
复制代码

public class SingleRedisLock {

     JedisPool jedisPool = new JedisPool("192.168.200.128",6379);

     //锁过期时间
     protected long internalLockLeaseTime = 30000;

     //获取锁的超时时间
     private long timeout = 999999;

     /**
      * 加锁
      * @param lockKey 锁键
      * @param requestId 请求唯一标识
      * @return
      */
     SetParams setParams = SetParams.setParams().nx().px(internalLockLeaseTime);

     public boolean tryLock(String lockKey, String requestId){

         String threadName = Thread.currentThread().getName();

         Jedis jedis = this.jedisPool.getResource();

         Long start = System.currentTimeMillis();

         try{
             for (;;){
                 String lockResult = jedis.set(lockKey, requestId, setParams);
                 if ("OK".equals(lockResult)){
                     System.out.println(threadName+":   获取锁成功");
                     return true;
                 }
                 //否则循环等待，在timeout时间内仍未获取到锁，则获取失败
                 System.out.println(threadName+":   获取锁失败，等待中");
                 long l = System.currentTimeMillis() ‐ start;
                 if (l>=timeout) {
                     return false;
                 }
                 try {
                     Thread.sleep(100);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         }finally {
             jedis.close();
         }

     }
 }
复制代码

/**
      * 解锁
      * @param lockKey 锁键
      * @param requestId 请求唯一标识
      * @return
      */
 public boolean releaseLock(String lockKey,String requestId){

     String threadName = Thread.currentThread().getName();
     System.out.println(threadName+"：释放锁");
     Jedis jedis = this.jedisPool.getResource();

     String lua =
         "if redis.call('get',KEYS[1]) == ARGV[1] then" +
         "   return redis.call('del',KEYS[1]) " +
         "else" +
         "   return 0 " +
         "end";

     try {
         Object result = jedis.eval（lua, Collections.singletonList(lockKey),
                                    Collections.singletonList(requestId));
         if("1".equals(result.toString())){
             return true;
         }
         return false;
     }finally {
         jedis.close();
     }

 }
复制代码

public class LoclTest {

     public static void main(String[] args) {

         //模拟多个5个客户端
         for (int i=0;i<5;i++) {
             Thread thread = new Thread(new LockRunnable());
             thread.start();
         }
     }

     private static class LockRunnable implements Runnable {
         @Override
         public void run() {

             SingleRedisLock singleRedisLock = new SingleRedisLock();

             String requestId = UUID.randomUUID().toString();
             boolean lockResult = singleRedisLock.tryLock("lock", requestId);
             if (lockResult){

                 try {
                     TimeUnit.SECONDS.sleep(5);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }

             singleRedisLock.releaseLock("lock",requestId);
         }
     }
 }
复制代码

     org.apache.commons
     commons‐pool2
 
 
 
     org.redisson
     redisson‐spring‐boot‐starter
     3.13.1
 
复制代码

server:
   redis:
     host: 192.168.200.150
     port: 6379
     database: 0
     jedis:
       pool:
         max‐active: 500
         max‐idle: 1000
         min‐idle: 4
复制代码

@Value("${spring.redis.host}")
 private String host;

 @Value("${spring.redis.port}")
 private String port;

 @Bean
 public RedissonClient redissonClient(){
     RedissonClient redissonClient;

     Config config = new Config();
     String url = "redis://" + host + ":" + port;
     config.useSingleServer().setAddress(url);

     try {
         redissonClient = Redisson.create(config);
         return redissonClient;
     } catch (Exception e) {
         e.printStackTrace();
         return null;
     }
 }
复制代码

@Component
 public class RedissonLock {

     @Autowired
     private RedissonClient redissonClient;

     /**
      * 加锁
      * @param lockKey
      * @return
      */
     public boolean addLock(String lockKey){

         try {
             if (redissonClient == null){
                 System.out.println("redisson client is null");
                 return false;
             }

             RLock lock = redissonClient.getLock(lockKey);

             //设置锁超时时间为5秒，到期自动释放
             lock.lock(5, TimeUnit.SECONDS);

             System.out.println(Thread.currentThread().getName()+":  获取到锁");

             //加锁成功
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         }
     }

     public boolean releaseLock(String lockKey){

         try{
             if (redissonClient == null){
                 System.out.println("redisson client is null");
                 return false;
             }

             RLock lock = redissonClient.getLock(lockKey);
             lock.unlock();
             System.out.println(Thread.currentThread().getName()+":  释放锁");
             return true;
         }catch (Exception e){
             e.printStackTrace();
             return false;
         }
     }
 }
复制代码

@SpringBootTest
 @RunWith(SpringRunner.class)
 public class RedissonLockTest {

     @Autowired
     private RedissonLock redissonLock;

     @Test
     public void easyLock(){
         //模拟多个10个客户端
         for (int i=0;i<10;i++) {
             Thread thread = new Thread(new LockRunnable());
             thread.start();
         }

         try {
             System.in.read();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     private class LockRunnable implements Runnable {
         @Override
         public void run() {
             redissonLock.addLock("demo");
             try {
                 TimeUnit.SECONDS.sleep(3);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             redissonLock.releaseLock("demo");
         }
     }
 }
复制代码