1. 事务冲突的问题

1.1 举例

对同一张卡，三个人同时想在双11抢购商品，抢购的商品分别价值8000、5000、1000元，但是卡里只有10000元。

1.2 悲观锁

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

1.3 乐观锁

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

1.4 Redis中的乐观锁 WATCH key [key …]

在执行multi之前，先执行watch key1 [key2],可以监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

127.0.0.1:6379> set balance 100--- 在客户端1中
127.0.0.1:6379> watch balance
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incrby balance 10
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 110--- 在客户端2中
127.0.0.1:6379> watch balance
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379(TX)> incrby balance 20
QUEUED
127.0.0.1:6379(TX)> exec
(nil)

1.5 Redis事务三特性

1. 单独的隔离操作
   事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
2. 没有隔离级别的概念
   队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行。
3. 不保证原子性
   事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚。

2. 秒杀案例

2.1 相关代码

package com.atguigu;import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;// 连接池解决连接超时的问题
public class JedisPoolUtil {private static volatile JedisPool jedisPool = null;private JedisPoolUtil() {}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  PONGjedisPool = new JedisPool(poolConfig, "192.168.44.168", 6379, 60000 );}}}return jedisPool;}public static void release(JedisPool jedisPool, Jedis jedis) {if (null != jedis) {jedisPool.returnResource(jedis);}}}

package com.atguigu;import java.io.IOException;
import java.util.HashSet;
import java.util.List;
import java.util.Set;import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.slf4j.LoggerFactory;import ch.qos.logback.core.rolling.helper.IntegerTokenConverter;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.ShardedJedisPool;
import redis.clients.jedis.Transaction;/****/
public class SecKill_redis {public static void main(String[] args) {Jedis jedis =new Jedis("192.168.44.168",6379);System.out.println(jedis.ping());jedis.close();}//秒杀过程public static boolean doSecKill(String uid,String prodid) throws IOException {//1 uid和prodid非空判断if(uid == null || prodid == null) {return false;}//2 连接redis//Jedis jedis = new Jedis("192.168.44.168",6379);//通过连接池得到jedis对象JedisPool jedisPoolInstance = JedisPoolUtil.getJedisPoolInstance();Jedis jedis = jedisPoolInstance.getResource();//3 拼接key// 3.1 库存keyString kcKey = "sk:"+prodid+":qt";// 3.2 秒杀成功用户keyString 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(userKey, uid)) {System.out.println("已经秒杀成功了，不能重复秒杀");jedis.close();return false;}//6 判断如果商品数量，库存数量小于1，秒杀结束if(Integer.parseInt(kc)<=0) {System.out.println("秒杀已经结束了");jedis.close();return false;}//7 秒杀过程//使用事务Transaction multi = jedis.multi();//组队操作multi.decr(kcKey);multi.sadd(userKey,uid);//执行List<Object> results = multi.exec();if(results == null || results.size()==0) {System.out.println("秒杀失败了....");jedis.close();return false;}//7.1 库存-1//jedis.decr(kcKey);//7.2 把秒杀成功用户添加清单里面//jedis.sadd(userKey,uid);System.out.println("秒杀成功了..");jedis.close();return true;}
}

package com.atguigu;import java.io.IOException;
import java.util.HashSet;
import java.util.List;
import java.util.Set;import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.slf4j.LoggerFactory;import ch.qos.logback.core.joran.conditional.ElseAction;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.ShardedJedisPool;
import redis.clients.jedis.Transaction;public class SecKill_redisByScript {private static final  org.slf4j.Logger logger =LoggerFactory.getLogger(SecKill_redisByScript.class) ;public static void main(String[] args) {JedisPool jedispool =  JedisPoolUtil.getJedisPoolInstance();Jedis jedis=jedispool.getResource();System.out.println(jedis.ping());Set<HostAndPort> set=new HashSet<HostAndPort>();//	doSecKill("201","sk:0101");}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..\":usr\";\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;}
}

package com.atguigu;import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Random;import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.ws.soap.AddressingFeature.Responses;/*** 秒杀案例*/
public class SecKillServlet extends HttpServlet {private static final long serialVersionUID = 1L;public SecKillServlet() {super();}protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {String userid = new Random().nextInt(50000) +"" ;String prodid =request.getParameter("prodid");//boolean isSuccess=SecKill_redis.doSecKill(userid,prodid);boolean isSuccess= SecKill_redisByScript.doSecKill(userid,prodid);response.getWriter().print(isSuccess);}}

2.2 模拟并发工具httpd-tools

先通过 yum安装httpd-tools然后通过这个工具测试
先写好一个postfile文件

这里存在问题，在秒杀结束后优惠成功，而且查询库存之后发现库存是-3！

3. 设计一个秒杀系统

Redis 可以通过多种机制实现秒杀功能，主要利用其高性能和支持原子操作的特点。以下是一个简单的实现步骤：

3.1 预热库存

在秒杀活动开始之前，将商品库存信息预热到 Redis 中。这样可以确保秒杀时的高并发请求能迅速响应。

// 商品库存key
String productStockKey = "product:stock:" + productId;// 设置库存数量
redisTemplate.opsForValue().set(productStockKey, stock);

3.2 秒杀请求

秒杀请求到达时，首先判断库存是否充足，如果充足则减库存并生成订单。

public String seckillProduct(String userId, String productId) {// 商品库存keyString productStockKey = "product:stock:" + productId;// 执行Lua脚本，原子性减库存并返回剩余库存String luaScript ="if (redis.call('exists', KEYS[1]) == 1) then " +"local stock = tonumber(redis.call('get', KEYS[1])); " +"if (stock > 0) then " +"redis.call('decr', KEYS[1]); " +"return stock - 1; " +"else " +"return -1; " +"end; " +"else " +"return -1; " +"end;";DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);Long stock = redisTemplate.execute(redisScript, Collections.singletonList(productStockKey));if (stock != null && stock >= 0) {// 生成订单逻辑createOrder(userId, productId);return "秒杀成功，剩余库存: " + stock;} else {return "秒杀失败，库存不足";}
}

3.3 生成订单

在减库存成功之后，生成订单记录。可以将订单信息存储到数据库中。

private void createOrder(String userId, String productId) {Order order = new Order();order.setUserId(userId);order.setProductId(productId);order.setOrderTime(LocalDateTime.now());orderRepository.save(order);  // 假设有一个 OrderRepository 来保存订单
}

3.4 限流与防刷

为了防止刷单和恶意请求，可以引入限流机制。可以使用 Redis 的令牌桶算法实现限流。

public boolean isAllowed(String userId) {String tokenBucketKey = "token:bucket:" + userId;String luaScript ="local rate = 10; " +  // 令牌生成速率"local capacity = 50; " +  // 令牌桶容量"local tokenCount = redis.call('get', KEYS[1]); " +"if (tokenCount == false) then " +"tokenCount = capacity; " +"else " +"tokenCount = tonumber(tokenCount); " +"end; " +"if (tokenCount > 0) then " +"redis.call('decr', KEYS[1]); " +"return true; " +"else " +"return false; " +"end;";DefaultRedisScript<Boolean> redisScript = new DefaultRedisScript<>(luaScript, Boolean.class);return redisTemplate.execute(redisScript, Collections.singletonList(tokenBucketKey));
}

4. 总结

1. 超时问题 通过Redis连接池解决
2. 超卖问题通过Lua脚本解决
3. watch的乐观锁会造成库存问题