【无标题】

```xml

```xml

```xml

```xml

```java
package com.me.hh;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * Project: me
 * Package: com.me.hh
 * Date: 2017/11/23 16:16
 * Author: Simeon
 */
public class SimpleRedisLock {

    public static ThreadLocal<Jedis> holder = new ThreadLocal<>();

    public static JedisPool jedisPool = new JedisPool(new JedisPoolConfig(), "localhost");

    public static void acquire(String lock){
        Jedis jedis = jedisPool.getResource();
        while(jedis.setnx(lock, "") == 0){
            System.out.println(Thread.currentThread().getName()+"我卡在了jedis.setnx(lock,");
        }     //set and if not exist 设置key并判断是否存在
        holder.set(jedis);
    }

    public static void release(String lock){
        Jedis jedis = holder.get();
        jedis.del(lock);
        jedis.close();
    }

}






package com.me.hh;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;

/**
 * Project: me
 * Package: com.me.hh
 * Date: 2017/11/23 16:00
 * Author: Simeon
 */
public class LockTest {

    public static int i = 0;
    public static CountDownLatch countDownLatch = new CountDownLatch(3); //计数器为3

    public static void main(String[] args) throws InterruptedException {
        new Thread(new CountRunnable("test-1"),"test-1").start();
        new Thread(new CountRunnable("test-2"),"test-2").start();
        new Thread(new CountRunnable("test-3"),"test-3").start();
        countDownLatch.await();  //只有计数器为0才会执行后面的，否则堵塞。保证先执行子线程，在跑后面的。
        System.out.println("主线程开始------");
        System.out.println(LockTest.i);
    }

    static class CountRunnable implements Runnable{
        private String name;

        public CountRunnable(String name){
            this.name = name;
        }
        @Override
        public void run() {

            SimpleRedisLock.acquire("lock");
            for(int j = 0; j < 1000; j++){
                LockTest.i++;
            }
            SimpleRedisLock.release("lock");

            System.out.println(name+"结束！");
            countDownLatch.countDown();  //每当一个线程结束，计数器--
        }
    }
}

简单版本的问题
测试代码中启动了3个线程竞争同一个分布式锁，如果三个线程中，有任意一个线程在调用SimpleRedisLock的acquire成功之后异常退出，没有释放锁，另外两个线程会死循环等待在SETNX命令上，简单修改一下LockTest，模拟test-1异常退出的情况：

@Override
public void run() {
    try {
        cyclicBarrier.await();
        for(int j = 0; j < 10000; j++){
            SimpleRedisLock.acquire("lock");
            if(Thread.currentThread().getName().equals("test-1")){
                throw new RuntimeException();
            }
            LockTest.i++;
            SimpleRedisLock.release("lock");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }finally {
        countDownLatch.countDown();
    }
}
线程test-1在获取到分布式锁之后，因为运行时异常退出（也有可能是因为进程、机器crash，OOM等各种问题），没有正确的释放锁，导致线程test-2、test-3死循环执行SETNX命令。

解决死锁问题
按照Redis文档给出的一种解决方法，重新修改acquire方法：

public static void acquire(String lock){
    Jedis jedis = jedisPool.getResource();
    //1.先尝试用setnx命令获取锁,key为参数lock,值为当前时间+要持有锁的时间hold_time
    while(jedis.setnx(lock, String.valueOf(System.currentTimeMillis() + hold_time)) == 0){
        //2.如果获取失败,检查lock对应的值是否已超时
        String expireTime = jedis.get(lock);
        if(expireTime != null && Long.parseLong(expireTime) < System.currentTimeMillis()){
            //3.如果已经超时了,使用getset命令,设置新的超时时间
            String oldExpire = jedis.getSet(lock, String.valueOf(System.currentTimeMillis() + hold_time));
            if(oldExpire != null && Long.parseLong(expireTime) < System.currentTimeMillis()){
                //4.如果setget命令返回的值,依然是过期时间,认为获取锁成功
                break;
            }
        }
    }
    holder.set(jedis);
}

测试代码执行结果：

test-1异常退出情况
在test-1线程退出后，程序正常执行，并得到了正确结果2万。但这个版本依旧有两个问题没有解决:

test-1线程异常退出，test-2、test-3线程同时执行setnx失败，获取expireTime，发现已经小于currentTime，开始执行getset命令。假设test-2先执行了getset，获取锁成功。test-3线程在执行getset时，返回的是test-2设置的未超时的时间戳，是一个未超时的时间，获取锁失败。功能上没有问题，但test-2线程持有的锁的有效期时间戳已经被test-3修改了。

如果test-2线程在持有锁的期间，因为网络抖动等原因，操作（测试代码中对应++操作部分）还没有完成，但锁已经超时了。 如何确定是否要释放锁（即使客户端记录自

己的超时时间戳也没用，问题1中已经描述了时间戳被其他线程修改的情况）？在需要互斥访问资源的场景，执行时间超过锁超时时间的情况下，怎么解决多个节点同时访问资源的情况（同时执行++操作）？

解决问题
重新修改获取锁的代码：

public class SimpleRedisLock {
 
    public static long hold_time = 3000;
 
    public static ThreadLocal<Jedis> holder = new ThreadLocal<>();
 
    public static ThreadLocal<String> expireHolder = new ThreadLocal<>();
 
    public static JedisPool jedisPool = new JedisPool(new JedisPoolConfig(), "localhost");
 
    public static void acquire(String lock){
        Jedis jedis = jedisPool.getResource();
        //1.先尝试用setnx命令获取锁,key为参数lock,值为当前时间+要持有锁的时间hold_time
        while(jedis.setnx(lock, String.valueOf(System.currentTimeMillis() + hold_time)) == 0){
            //2.如果获取失败,先watch lock key
            jedis.watch(lock);
            //3.获取当前超时时间
            String expireTime = jedis.get(lock);
            if(expireTime != null && Long.parseLong(expireTime) < System.currentTimeMillis()){
                //4.如果超时时间小于当前时间,开事务准备更新lock值
                Transaction transaction = jedis.multi();
                Response<String> response = transaction.getSet(lock, String.valueOf(System.currentTimeMillis() + hold_time));
                //5.步骤2设置了watch,如果lock的值被其他线程修改,不是执行事务中的命令
                if(transaction.exec() != null){
                    String oldExpire = response.get();
                    if(oldExpire != null && Long.parseLong(expireTime) < System.currentTimeMillis()){
                        //6.如果setget命令返回的值依然是过期时间,认为获取锁成功(加了watch之后,这里返回的应该一直是超时时间)
                        break;
                    }
                }
            }else{
                //如果key未超时,解除watch
                jedis.unwatch();
            }
        }
        //设置客户端超时时间
        expireHolder.set(jedis.get(lock));
        holder.set(jedis);
    }
 
    public static void release(String lock){
        Jedis jedis = holder.get();
        //比较客户端超时时间与lock值,判断是否还由自己持有锁
        if(jedis.get(lock).equals(expireHolder.get())){
            jedis.del(lock);
        }
        jedis.close();
    }
 
}

新的acquire方法，通过watch、redis事务，保证只有一个客户端能执行getset，并记录了锁超时时间，解决了问题一和问题二的前半部分。对于锁超时导致的两个客户端同时访问资源，只能靠业务代码保证锁超时时间内可以完成处理（可以在release时检查是否超时，如果超时回滚所有操作，但对不能回滚的，例如++操作就比较麻烦），或者放弃死锁容错功能，需要看场景衡量。