Redis-事物

Redis事物

定义

1、 Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

2、 Redis事务的主要作用就是串联多个命令防止别的命令插队

Multi、Exec、discard

1、组队阶段：输入 Multi 命令开始，输入的命令会被依次放入队列缓存，但不执行。
2、收到 EXEC 后，之前输入的命令依次执行，事务中任意命令执行失败，其余的命令依然被执行，discard放弃组队
3、在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。

事物的错误处理

1、成功演示

2、失败演示

组队时有命令错误，执行时都不会成功

事物的冲突问题

多人拥有同一个账户共有10000元，同时购买东西， A -8000， B -5000， C -1000

1000 - 8000 - 5000 - 1000 = -4000

针对上述问题，Redis中有两种解决方式，通过锁的方式解决该问题

1、悲观锁

每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁

2、乐观锁（抢票）

每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的。

watch key1 [key2…] 乐观锁演示

在执行multi之前，先用watch监视一个或者多个key，如果在事物执行之前，当前的key被其它命令改动，则事物被打断

Redis事物三特性

• 单独的隔离操作
  – 事物在执行过程中，不会被其它的操作命令打断
• 没有隔离级别概念
  – 队列中的命令没有提交之前都不会实际被执行，事物没有提交前任何命令都不会被执行
• 不保证原子性
  – 事物中如果有一条命令失败，其它命令依然会执行，没有回滚

秒杀测试案例

1、使用ab工具
测试工具
Apache Bench

安装
yum -y install httpd-tools

测试命令

ab -n 2000 -c 200 -k -p ~/postfile -T application/x-www-form-urlencoded http://192.168.2.115:8081/Seckill/doseckill

参数 描述
-n 测试次数
-c 并发线程个数
-p POST数据文件(参数文件)
-T Content-type头信息

并发控制

2、超卖问题

• 超卖描述

商品已经卖完了，但是客户还是可以买到

• 1、请求次数的量巨大，避免重复创建对象导致时间问题，使用连接池来解决超时问题

public static JedisPool getJedisPoolInstance() {
		if (null == jedisPool) {
			synchronized (JedisPoolUtil.class) {
				if (null == jedisPool) {
					JedisPoolConfig poolConfig = new JedisPoolConfig();
					poolConfig.setMaxTotal(200);
					poolConfig.setMaxIdle(32);
					poolConfig.setMaxWaitMillis(100*1000);
					poolConfig.setBlockWhenExhausted(true);
					poolConfig.setTestOnBorrow(true);  // ping  PONG
				 
					jedisPool = new JedisPool(poolConfig, "192.168.135.100", 6379, 60000 );
				}
			}
		}
		return jedisPool;
	}

以常规的形式去测试，会发现在请求数大于秒杀库存的情况下，会出现库存变为负值的情况

• 2、加入事务控制(乐观锁)来优化案例

//秒杀过程
	public static boolean doSecKill(String uid,String prodid) throws IOException {
		//1 uid和prodid非空判断
		if (uid == null || prodid == null) {
			return false;
		}

		//2 连接redis
		//可以解决超时问题
		JedisPool pool = JedisPoolUtil.getJedisPoolInstance();
		Jedis jedis = pool.getResource();
		//通过连接池得到jedis对象


		//3 拼接key
		// 3.1 库存key
		String kcKey = "sk:" + prodid + ":qt";
		// 3.2 秒杀成功用户key
		String userKey = "sk:" + prodid + ":user";

		//监视库存
		jedis.watch(kcKey);

		//4 获取库存，如果库存null，秒杀还没有开始
		String kc = jedis.get(kcKey);
		if (kc == null) {
			System.out.println("秒杀还没开始");
			jedis.close();
			return false;
		}
		// 5 判断用户是否重复秒杀操作

		if (jedis.sismember(uid, userKey)) {
			System.out.println("已经秒杀过不能再秒杀了");
			jedis.close();
			return false;
		}

		//6 判断如果商品数量，库存数量小于1，秒杀结束

		if (Integer.parseInt(kc) <= 0) {
			System.out.println("秒杀已结束");
			jedis.close();
			return false;
		}


		//7 秒杀过程
		//使用事务
		Transaction transaction = jedis.multi();


		//组队操作
		//7.1 库存-1
		//7.2 把秒杀成功用户添加清单里面
		transaction.decr(kcKey);
		transaction.sadd(userKey, uid);
		//执行
		List<Object> list = transaction.exec();
		if (list != null && list.size() != 0) {
			System.out.println("秒杀成功");
		} else {
			System.out.println("秒杀失败");
		}

		//7.1 库存-1
		//7.2 把秒杀成功用户添加清单里面
		/*jedis.decr(kcKey);

		jedis.sadd(userKey, uid);*/

		jedis.close();
		return true;
	}

乐观锁解决方式可能会造成库存遗留问题
​ 这种方式在库存与请求数差别不大的时候可能会导致库存遗留问题， 用悲观锁可以有效解决这个问题

redis不能直接使用悲观锁，借用LUA脚本解决

• 3、使用悲观锁（LUA）解决秒杀问题

	static String secKillScript ="local userid=KEYS[1];\r\n" +
			"local prodid=KEYS[2];\r\n" +
			"local qtkey='sk:'..prodid..\":qt\";\r\n" +
			"local usersKey='sk:'..prodid..\":user\";\r\n" +
			"local userExists=redis.call(\"sismember\",usersKey,userid);\r\n" +
			"if tonumber(userExists)==1 then \r\n" +
			"   return 2;\r\n" +
			"end\r\n" +
			"local num= redis.call(\"get\" ,qtkey);\r\n" +
			"if tonumber(num)<=0 then \r\n" +
			"   return 0;\r\n" +
			"else \r\n" +
			"   redis.call(\"decr\",qtkey);\r\n" +
			"   redis.call(\"sadd\",usersKey,userid);\r\n" +
			"end\r\n" +
			"return 1";
			 
	static String secKillScript2 = 
			"local userExists=redis.call(\"sismember\",\"{sk}:0101:usr\",userid);\r\n" +
			" return 1";

	public static boolean doSecKill(String uid,String prodid) throws IOException {

		JedisPool jedispool =  JedisPoolUtil.getJedisPoolInstance();
		Jedis jedis=jedispool.getResource();

		 //String sha1=  .secKillScript;
		String sha1=  jedis.scriptLoad(secKillScript);
		Object result= jedis.evalsha(sha1, 2, uid,prodid);

		  String reString=String.valueOf(result);
		if ("0".equals( reString )  ) {
			System.err.println("已抢空！！");
		}else if("1".equals( reString )  )  {
			System.out.println("抢购成功！！！！");
		}else if("2".equals( reString )  )  {
			System.err.println("该用户已抢过！！");
		}else{
			System.err.println("抢购异常！！");
		}
		jedis.close();
		return true;
	}