redis实战笔记

1.redis数据结构

  1. string
    string可以存储字符串、整数或者浮点数。
    当存储整数时,可以进行自增或者自减操作



一个键对应一个值


  1. list列表
    一个列表结构可以有序的存储多个字符串,且可以重复。
    列表可以从序列的两端推入(RPUSH、LPUSH)或者弹出元素(RPOP、LPOP),也可以返回某下标的元素(lindex(key,index))还可以存储任务信息、最近浏览过的文章信息或常用联系人信息。
    还可以使用阻塞弹出和推入命令实现消息传递和任务队列。




  2. set集合
    集合和列表都可以存储多个字符串,可以删除集合中的某个或多个元素(srem),可以返回集合的所有元素(smembers(key)),不同在于set集合存储的字符串是不可重复且无序的。
    集合真正厉害的地方是组合和处理多个集合
    sdiff:两个集合的差集
    sinter:交集
    sunion:并集



  1. hash散列
    redis的散列可以存储多个键和值得映射,各个键不相同,且无序




  2. zset有序集合
    zset有序集合和散列一样,都是存储多个键值对,有序集合的键被称为成员(member),值被称为分数(score),既可以根据键来访问元素,也可以根据值和值得排列顺序来访问元素。
    可以根据键获取排名(zrank),根据键获取分值(zscore)
    也可以获取范围内的排名(zrange)
    取并集(zunionstore),两个集合相同元素的score取最小值
    取交集(zinterstore),两个集合相同元素的score取和




2.redis的发布和订阅

发送者负责向频道发送消息,频道内的所有订阅者都会获得消息
subscribe channel --订阅一个频道
unsubscribe channel --退订给定频道
public channel msg --向给定频道发送消息

3.基本的redis事务

redis的基本事务需要用到multi命令和exec命令,这种事务可以让一个客户端在不被其他客户端打断的情况下执行多个命令,在redis中,被multi命令和exec命令包围的命令会依次执行,直到所用的命令执行完毕为止。当一个事务执行完毕之后,redis才会执行其他客户端的命令。
在客户端中使用piepline()方法创建一个事物,在一切正常的情况下,客户端会自动的使用multi和exec命令包裹用户输入的多个命令,为了提升性能,会在事务执行时一次性地将所有命令都发送给redis,减少连接次数,提高性能。
当使用piepline(false)时,将使用非事务型流水线,被包裹的命令一次连接执行全部命令,但不以事务方式运行。



使用流水线性能提高多倍。

    public void benchmarkUpdateToken(Jedis conn, int duration) {
        try{
            @SuppressWarnings("rawtypes")
            Class[] args = new Class[]{
                Jedis.class, String.class, String.class, String.class};
            Method[] methods = new Method[]{
                this.getClass().getDeclaredMethod("updateToken", args),
                this.getClass().getDeclaredMethod("updateTokenPipeline", args),
            };
            for (Method method : methods){
                int count = 0;
                long start = System.currentTimeMillis();
                long end = start + (duration * 1000);
                while (System.currentTimeMillis() < end){
                    count++;
                    method.invoke(this, conn, "token", "user", "item");
                }
                long delta = System.currentTimeMillis() - start;
                System.out.println(
                        method.getName() + ' ' +
                        count + ' ' +
                        (delta / 1000) + ' ' +
                        (count / (delta / 1000)));
            }
        }catch(Exception e){
            throw new RuntimeException(e);
        }
    }
    public void updateToken(Jedis conn, String token, String user, String item) {
        long timestamp = System.currentTimeMillis() / 1000;
        conn.hset("login:", token, user);
        conn.zadd("recent:", timestamp, token);
        if (item != null) {
            conn.zadd("viewed:" + token, timestamp, item);
            conn.zremrangeByRank("viewed:" + token, 0, -26);
            conn.zincrby("viewed:", -1, item);
        }
    }

    public void updateTokenPipeline(Jedis conn, String token, String user, String item) {
        long timestamp = System.currentTimeMillis() / 1000;
        Pipeline pipe = conn.pipelined();
        pipe.multi();
        pipe.hset("login:", token, user);
        pipe.zadd("recent:", timestamp, token);
        if (item != null){
            pipe.zadd("viewed:" + token, timestamp, item);
            pipe.zremrangeByRank("viewed:" + token, 0, -26);
            pipe.zincrby("viewed:", -1, item);
        }
        pipe.exec();
    }

//updateToken 52558 5 10511
//updateTokenPipeline 476595 5 95319

watch命令:
在使用watch命令对键进行监视之后,直到执行exec命令的这段时间里,如果其他客户端对被监视的键进行了修改,那么在执行exec时,事务将失败。(乐观锁)
比如在执行购买商品事务时监视商品,当商品发生变化时,事务执行失败。

   public boolean purchaseItem(
            Jedis conn, String buyerId, String itemId, String sellerId, double lprice) {

        String buyer = "users:" + buyerId;
        String seller = "users:" + sellerId;
        String item = itemId + '.' + sellerId;
        String inventory = "inventory:" + buyerId;
        long end = System.currentTimeMillis() + 10000;

        while (System.currentTimeMillis() < end){
            conn.watch("market:", buyer); //对市场中买家的商品进行监视

            double price = conn.zscore("market:", item);
            double funds = Double.parseDouble(conn.hget(buyer, "funds"));
            if (price != lprice || price > funds){
                conn.unwatch();
                return false;
            }

            Transaction trans = conn.multi(); // 事务中转移商品和钱
            trans.hincrBy(seller, "funds", (int)price);
            trans.hincrBy(buyer, "funds", (int)-price);
            trans.sadd(inventory, itemId);
            trans.zrem("market:", item);
            List<Object> results = trans.exec(); //如果exec方法没有引发watchError错误,说明该键没有被更改,事务执行成功,并且watch执行结束
            // null response indicates that the transaction was aborted due to
            // the watched key changing.
            if (results == null){
                continue;
            }
            return true;
        }

        return false;
    }

4.键的过期时间

        // 设置过期时间,对于list,set,hash来说,只能为键设置过期时间,而无法为键里的单个元素设置过期时间
        conn.expire("tran", 2);
        // 查看键距离过期还有多长时间
        Long tran = conn.ttl("tran");

5.持久化策略

  • 快照持久化
    redis可以通过创建快照来获得存储在内存的数据的某个时间点上的副本。
save 60 1000    //60秒内有1000次写入则执行快照
stop-writes-on-bgsave-error no //创建快照失败后是否执行写命令
rdbcompression yes //是否对快照文件进行压缩
dbfilename dump.rdb //快照创建的副本文件名

创建快照的几种方式

  1. BGSAVE,会创建子线程
  2. SAVE
  3. 设置save配置选项,触发条件后会执行BGSAVE命令

快照的缺陷

  1. 在只使用快照持久化保存数据时,如果系统真的发生崩溃,用户将丢失最近一次生成快照之后更改的所有数据。
  2. 当数据量太大时,BGSAVE创建的子线程要将数据保存到硬盘中耗费的时间越来越多。
  • AOF持久化
    简单来说,AOF持久化会将被执行的写命令写到AOF文件的末尾,以此来记录文件的变化。因此,redis只要从头到尾重新执行一次AOF文件的写命令,就可以恢复AOF文件所记录的数据集,AOF文件可能会很大,可以使用bgrewriteaof命令消除aof文件中的冗余命令。


    image.png
appendonly no //是否使用AOF持久化
appendfsync everysec //多久才将写入的内容同步到硬盘,可选always、everysec、no
no-appendfsync-on-rewrite no 
auto-aof-rewrite-percentage 100 //AOF文件体积上次重写大100%时重新执行bgrewriteaof
auto-aof-rewrite-min-size 64mb //只有在AOF文件体积大于64M时才执行bgrewriteaof,这个命令会移除AOF文件中的冗余命令来重写AOF文件,使AOF文件尽可能的小
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。