秒杀的乐观锁----redis（hibernate乐观锁原理）

乐观锁大致的意思是不具有互斥性，没有等待，大家都可以试试，但是谁成功不确定。像秒杀这种场景就非常符合乐观锁。

最近拉勾的老师讲redis的时候讲述了乐观锁和分布式锁。

其中乐观锁的操作就是下面思路：

1:利用redis的watch功能，监控这个key的状态值

2:获取到这个值后，创建事务

3:给这个key到值+1

4:执行这个事务。

watch的作用就是

当 Redis 使用 exec 命令执行事务的时候，它首先会去比对被 watch 命令所监控的键值对，如果没有发生变化，那么它会执行事务队列中的命令，提交事务；如果发生变化，那么它不会执行任何事务中的命令，而去事务回滚。

其实这个watch有点像上篇将zookeeper实现分布式锁有点像，也有点类似与抢锁的概念。只是乐观锁是大家一起上，没有堵塞。而zookeeper实现的 分布式锁有阻塞。

好了，说完思路说代码了。

package com.redis;


import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

import java.util.List;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;

/**
 * Created by zhonglieming on 2020/7/31.
 */
public class TestCAS {


    public static void main(String[] args) {

        Jedis jedis = new Jedis("xxxxx", 6379);
			//刚开始，设定秒杀的key ,就是001，假设抢前5
        jedis.set("001", "0");
        jedis.close();
        System.out.println("初始化完成");

        CountDownLatch t1 = new CountDownLatch(5);

      	//通过for循环模拟 许多请求
        for (int i = 0; i < 20; i++) {

            if (t1.getCount() == 0) {
                System.out.println("===>" + i);
                break;
            }
            for (int j = 0; j < 100; j++) {
                if (t1.getCount() == 0) {
                    System.out.println("===>" + i);
                    break;
                }
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Jedis jedis = new Jedis("xxxxx", 6379, 20000);
                        try {
                          	//设定watch
                            jedis.watch("001");
                          
                            int v = Integer.valueOf(jedis.get("001"));
                            String userInfo = UUID.randomUUID().toString();
                            //还没有秒杀完
                            if (v < 5) {
																//开启事务
                                Transaction tx = jedis.multi();
                                //拿到key对应的值，进行累加
                                tx.incr("001");
                              	//查看运行的结果，如果成功，说明秒杀进了
                                List list = tx.exec();
                                if (list != null && list.size() > 0) {
                                    t1.countDown();
                                    System.out.println("用户：" + userInfo + ",秒杀成功；当前成功人数：" + (v + 1));
                                }else{
                                  	//失败，秒杀不成功，没事，因为有watch的帮助，我们之前的
                                  	//tx.incr("001");会回滚，并不会真的加1，结束
                                    try {
                                        Thread.sleep(1000);
                                        System.out.println("失败，被别人抢去了");
                                    } catch (InterruptedException e) {
                                        e.printStackTrace();
                                    }
                                }
                            }
                        } finally {
                            jedis.close();
                        }
                    }
                }).start();

            }
        }


    }

}

结果如下：

初始化完成
用户：6a4ec317-8552-4fe3-9c5c-e95296bfb3fd,秒杀成功；当前成功人数：1
失败，被别人抢去了
失败，被别人抢去了
用户：63cabd11-d068-4673-9038-5725e0434057,秒杀成功；当前成功人数：2
失败，被别人抢去了
失败，被别人抢去了
用户：89417719-c2c2-4e2c-abbe-fd0a7afc5004,秒杀成功；当前成功人数：3
失败，被别人抢去了
用户：c3054774-12f9-4e90-8b8b-742e6c700566,秒杀成功；当前成功人数：4
失败，被别人抢去了
用户：2d835f46-8358-4800-a936-5611ca935198,秒杀成功；当前成功人数：5
。。。。。

中心思想就是 使用watch 进行监督，如果你执行累加操作前 这个值没有变化，就执行你的操作，
反之就结束了，保证了多线程情况下
同一时刻就只有一个任务对一个值进行变更操作。