注：原始资料来自享学课堂，加上自己的理解和修改

1、关于redis作为分布式锁的基本概念

1.1 缓存有效期

redis中的数据是能够设置过期时间的，时间到了之后，当前key会被自动删除，具体命令如下

127.0.0.1:6379> set a 12 ex 3 //设置3秒过期
OK
127.0.0.1:6379> get a
"12"
127.0.0.1:6379> get a //3秒之后数据就被删除了
(nil)
127.0.0.1:6379>

1.2 SETNX命令

setnx key value，当key已经存在时，不做任何操作，当key不存在时，设置key=value，测试指令如下：

127.0.0.1:6379> set a 12
OK
127.0.0.1:6379> get a
"12"
127.0.0.1:6379> setnx a 12  //a已经存在，添加失败
(integer) 0
127.0.0.1:6379> setnx b 12 //b不存在，添加成功
(integer) 1
127.0.0.1:6379> keys *
1) "b"
2) "a"
127.0.0.1:6379>

1.3 redis的lua脚本

轻量小巧的脚本语言，用于支持redis操作序列的原子性；lua里面的命令要么执行成功，要么执行失败，并且执行lua脚本的时候，其他的lua脚本和命令都不能执行

1.4 加锁过程

通过setnx向特定的key写入一个随机值，并同时设置失效时间，写值成功即加锁成功，指令测试如下

127.0.0.1:6379> set c 12 ex 12 nx
OK
127.0.0.1:6379> get c
"12"
127.0.0.1:6379> get c
"12"
127.0.0.1:6379> get c
"12"
127.0.0.1:6379> get c
"12"
127.0.0.1:6379> get c
"12"
127.0.0.1:6379> get c
(nil)
127.0.0.1:6379>

加锁注意点：

1. 必须给锁设置一个失效时间，避免死锁
2. 加锁时，每个节点产生一个随机字符串，避免锁误删
3. 写入随机值与设置失效时间必须是同时的，保证加锁是原子的

解锁注意点

匹配随机值，删除redis上的特定的key数据，要保证获取数据、判断一致以及删除数据三个操作是原子的；

执行如下lua脚本：

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

2、springboot结合redis实现分布式锁

2.1 准备lua脚本，放在resources下

lua脚本内容如下；

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

2.2 redis实现lock接口，实现基本的方法，实现自定义锁

@Service
public class RedisLock implements Lock {
	private static final String  KEY = "LOCK_KEY";
	@Resource
	private JedisConnectionFactory factory;
	private ThreadLocal<String> local = new ThreadLocal<>();

	//阻塞式的加锁
	@Override
	public void lock() {
		//1.尝试加锁
		if(tryLock()){
			return;
		}
		//2.加锁失败，当前任务休眠一段时间
		try {
			//此处会造成性能浪费，而是用zookeeper的监听机制和临时顺序节点就能避免这个问题
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		//3.递归调用，再次去抢锁
		lock();
	}

	@Override
	//阻塞式加锁,使用setNx命令返回OK的加锁成功，并生产随机值
	public boolean tryLock() {
		//产生随机值，标识本次锁编号
		String uuid = UUID.randomUUID().toString();
		Jedis jedis = (Jedis) factory.getConnection().getNativeConnection();

		/**
		 * key:我们使用key来当锁
		 * uuid:唯一标识，这个锁是我加的，属于我
		 * NX：仅当key不存在时，本语句的值才设入
		 * PX：给key加有效期，
		 * 1000：有效时间为 1 秒
		 */
		String ret = jedis.set(KEY, uuid,"NX","PX",1000);

		//设值成功--抢到了锁
		if("OK".equals(ret)){
			//抢锁成功，把锁标识号记录入本线程--- Threadlocal
			local.set(uuid);
			return true;
		}
		//key值里面有了，我的uuid未能设入进去，抢锁失败
		return false;
	}

	//正确解锁方式
	public void unlock() {
		//读取lua脚本
		String script = FileUtils.getScript("unlock.lua");
		//获取redis的原始连接
		Jedis jedis = (Jedis) factory.getConnection().getNativeConnection();
		//通过原始连接连接redis执行lua脚本，确保当前线程的uuid和redis的key中存储的值是一致的
		jedis.eval(script, Arrays.asList(KEY), Arrays.asList(local.get()));
	}

	//实现等待通知机制使用
	@Override
	public Condition newCondition() {
		return null;
	}

	//超时获取锁
	@Override
	public boolean tryLock(long time, TimeUnit unit)
			throws InterruptedException {
		return false;
	}

	//可中断获取锁
	@Override
	public void lockInterruptibly() throws InterruptedException {
	}

}

2.3 测试类

此处会有一个问题，如果多个线程在锁这里等待，执行线程释放锁的时候，其他多个等待线程就会去争夺这个锁，但是其实只能有一个线程获取锁，完全没有必要唤醒多个线程，这就是羊群效应。使用zookeeper临时顺序节点能够解决这个问题

@RestController
public class LockController {
    //总共有20张车票
    private static long count = 20;
    //使用CountDownLatch确保多个线程同时抢票
    private CountDownLatch countDownLatch = new CountDownLatch(5);

    @Resource(name="redisLock")
    private Lock lock;


    @RequestMapping(value = "/sale", method = RequestMethod.GET)
    public Long sale() throws InterruptedException {
        count = 20;
        countDownLatch = new CountDownLatch(5);

        System.out.println("-------共20张票，分五个窗口开售-------");
        new PlusThread().start();
        new PlusThread().start();
        new PlusThread().start();
        new PlusThread().start();
        new PlusThread().start();
        return count;
    }

    // 线程类模拟一个窗口买火车票
    public class PlusThread extends Thread {
        private int amount = 0;//抢多少张票

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "开始售票");
            countDownLatch.countDown();
            if (countDownLatch.getCount()==0){
                System.out.println("----------售票结果----------");
            }
            try {
                //所有线程在这里等待，知道5个线程都启动到达才继续执行
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            while (count > 0) {
                //此处会有一个问题，如果多个线程在这里等待，释放锁的时候，多个线程就会去争夺这个锁，但是其实只能有一个线程获取锁，完全没有必要唤醒多个线程，这就是羊群效应。使用zookeeper临时顺序节点能够解决这个问题
                lock.lock();
                try {
                    if (count > 0) {
                        //模拟卖票业务处理
                        amount++;
                        count--;
                    }
                }finally{
                    lock.unlock();
                }

                try {
                    Thread.sleep(10);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName() + "售出"+ (amount) + "张票");
        }
    }
}