redis

1.库的概念

2.发布和订阅

listener配置：

测试后发现存在重复消费和丢消息问题（只能收到客户端链接之后的消息）

3.事务和pipeline：

先看下没有事务时的执行情况：

然后我们用Pipeline：

可以看到每个线程的多个redis操作结果被放到了list<Object>中，且如果我们持续用redis-cli刷transaction的值会发现直到10s之后第二个redis命令执行(实际上在closePipeline之后)才出现transaction的key。查看executePipelined的实现：

如果我们手动close：

open和close其实初始化了connection中的pipeline对象在后续execute中如果pipeline被初始化则做不通的逻辑将结果放到List<Object> 并在close时取出并清空最后返回

pipeline和事务是不同的概念，pipeline并不保证原子性，更多的是客户端的行为来减少rtt，在不超过报文大小的情况下，pipeline中的命令会打包一起发送，结果也打包返回，当我们用事务时，则是每条命令分开发送，服务端响应queue直到exec返回结果。

pipeline非原子性实验：

 for (int i=0;i<1;i++) {
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {

                    List<Object>  result=redisTemplate.executePipelined(new RedisCallback<Object>() {
                        @Override
                        public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
                            System.out.println("pipeline start");
                            for (int j=0;j<1000;j++){
                                redisConnection.incrBy("transaction".getBytes(),1);
                            }
                            return null;
                        }
                    });
                    System.out.println(result);

                }
            });
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {

                    Object result=redisTemplate.execute(new RedisCallback<Object>() {
                        @Override
                        public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
                            System.out.println("dddd start");
                            for (int j=0;j<1000;j++){
                                System.out.println(redisConnection.incrBy("transaction".getBytes(),-1));
                            }

                            return null;
                        }
                    });
                    System.out.println(result);

                }
            });

我们在两个线程里：一个线程用pipeline自增1000次，另外一个线程里不用pipeline自减1000次，pipeline执行日志如下：

在递增到49时执行了不在pipeline中的命令：

可以看到在第243次也发生了同样的情况

事务：

我们发现redisTemplate提供的multi，exec，watch可以实现事务，同时execute也可以关于2者的区别：

转载：https://www.cnblogs.com/wuhaonan/p/10646277.html

我们用同样的方法测试下事务的原子性：

redisTemplate.execute(new SessionCallback() {
                        @Override
                        public Object execute(RedisOperations redisOperations) throws DataAccessException {
                            System.out.println("transaction start");
                            redisOperations.multi();
                            for (int i=0;i<1000;i++){
                                redisOperations.opsForValue().increment("transaction", 1);
                            }
                            List<Object> res = redisOperations.exec();
                            System.out.println(res);
                            return null;
                        }
                    });

 redisTemplate.execute(new SessionCallback() {
                        @Override
                        public Object execute(RedisOperations redisOperations) throws DataAccessException {
                            System.out.println("dddd start");
                            for (int i=0;i<1000;i++){
                                System.out.println(redisOperations.opsForValue().increment("transaction", -1));
                            }
                            return null;
                        }
                    });