【Redis】1、Jedis对管道、事务以及Watch的操作来应对高并发

对于一个互联网平台来说，高并发是经常会遇到的场景。最有代表性的比如秒杀和抢购。高并发会出现三个特点：

　　1、高并发读取

　　2、高并发写入（一致性）

　　3、出现超卖问题

前端如何应对？

1、缓存静态数据，例如图片，html页面，js等

2、搭建负载均衡集群，目前采用较多的为nginx

3、进行ip限制，限制同一个ip单位时间内发起的请求数量。或者建立ip黑名单，避免恶意攻击

4、考虑系统降级。比如当达到系统负载的时候返回一个静态处理页面

后端如何应对？

1、采用mysql读写分离，但是当高并发的时候mysql性能会降低。 一般来说，MySQL的处理性能会随着并发thread上升而上升，但是到了一定的并发度之后会出现明显的拐点，之后一路下降，最终甚至会比单thread的性能还要差。比如加减库存的操作，通常并发量不高的做法为：update xxx set count=count-xx where curcount>xx；这样可以充分利用mysql的事务锁来避免出现超卖的情况。但是并发量上了后，会因为排他锁等待而大大降低性能。

2、采用redis数据库，前置到mysql。思路如下：

2.1系统启动后，初始化sku信息到redis数据库，记录其可用量和锁定量

2.2使用乐观锁，采用redis的watch机制。逻辑为：

1.定义门票号变量，设置初始值为0。watchkey

2.watch该变量,watch(watchkey);

3.使用redis事务加减库存。首先获取可用量和抢购量比较，如果curcount>buycount，那么正常执行减库存和加锁定量操作：

Redis用法详细说明

1、Pipeline

利用pipeline的方式从client打包多条命令一起发出，不需要等待单条命令的响应返回，而Redis服务端会处理完多条命令后会将多条命令的处理结果打包到一起返回给客户端。所以pipeline适合批处理作业可以提升效率如：

1. public static void testMget() {
2. Jedis jedis = RedisCacheClient.getInstrance().getClient();
3. Set<String> keys = jedis.keys("cvfeedBackHandl_*");
4. List<String> result = Lists.newArrayList();
5. long t1 = System.currentTimeMillis();
6. for (String key : keys) {
7. result.add(jedis.get(key));
8. }
9. for (String src : result) {
10. System.out.println(src);
11. }
12. System.out.println(System.currentTimeMillis() - t1);
13. }
14. public static void testPipline() {
15. Jedis jedis = RedisCacheClient.getInstrance().getClient();
16. Set<String> keys = jedis.keys("cvfeedBackHandl_*");
17. List<Object> result = Lists.newArrayList();
18. Pipeline pipelined = jedis.pipelined();
19. long t1 = System.currentTimeMillis();
20. for (String key : keys) {
21. pipelined.<span style="font-family: Arial;">get</span>("testabcd");
22. }
23. result = pipelined.syncAndReturnAll();
24. for (Object src : result) {
25. System.out.println(src);
26. }
27. System.out.println(System.currentTimeMillis() - t1);
28. }

如第一个方法执行的时间是82ms

第二个方法执行的时间是9ms

注意：pipeline和事务都是异步调用返回结果的，即并不是等待每条命令执行完立马返回结果而是等待所有命令执行完之后再返回结果。pipelined.syncAndReturnAll()返回的是参与打包执行的每条命令的结果。如果上面改成：

1. for (String key : keys) {//keys长度为5
2. pipelined.get(key);
3. pipelined.del("testabcd");
4. }

返回结果将是

1. "test1"
2. 1
3. "test2"
4. 0
5. "test2"
6. 0
7. "test4"
8. 0
9. "test5"
10. 0

2、事务

事务是保证事务内的所有命令是原子操作，一般配合watch使用，事务的执行结果和pipeline一样都是采用异步的方式获取结果，multi.exec()提交事务，如果执行成功，其返回的结果和pipeline一样是所有命令的返回值，如果事务里面有两个命令那么事务的exec返回值会把两个命令的返回值组合在一起返回。如果事务被取消返回null。

3、watch

一般是和事务一起使用，当对某个key进行watch后如果其他的客户端对这个key进行了更改，那么本次事务会被取消，事务的exec会返回null。jedis.watch(key)都会返回OK
eg:

1. public static void testWach(){
2. Jedis jedis = RedisCacheClient.getInstrance().getClient();
3. String watch = jedis.watch("testabcd");
4. System.out.println(Thread.currentThread().getName()+"--"+watch);
5. Transaction multi = jedis.multi();
6. multi.set("testabcd", "23432");
7. try {
8. Thread.sleep(3000);
9. } catch (InterruptedException e) {
10. e.printStackTrace();
11. }
12. List<Object> exec = multi.exec();
13. System.out.println("---"+exec);
14. jedis.unwatch();
15. }
16. public static void testWatch2(){
17. Jedis jedis = RedisCacheClient.getInstrance().getClient();
18. String watch = jedis.watch("testabcd2");
19. System.out.println(Thread.currentThread().getName()+"--"+watch);
20. Transaction multi = jedis.multi();
21. multi.set("testabcd", "125");
22. List<Object> exec = multi.exec();
23. System.out.println("--->>"+exec);
24. }

Thread-2--OK
Thread-0--OK
--->>[OK]

---null//事务取消

4、事务与管道

当对某个key进行watch时，如果其他的客户端对key进行了更改事务可以做到取消事务操作但是管道不可以