Redis使用（Java）

目录

• 什么是Redis
• 为什么用Redis
• 如何使用Redis（5种数据类型）
• 底层数据结构

什么是Redis

Redis是一个开源的高性能键值对数据库。它通过提供多种键值数据类型来适应不同场景下的存储需求，并借助许多高层级的接口使其可以胜任如缓存、队列系统等不同的角色

为什么用Redis（特性）

• 存储结构

支持字符串、散列、列表、集合、有序集合等类型。与MySQL相比，对于小数据集的复杂关系操作更直观，性能更好

• 内存存储与持久化

Redis数据库中的所有数据都存储在内存中。由于内存的读写速度远快于硬盘，因此Redis在性能上对比其他基于硬盘存储的数据库有非常明显的优势

Redis提供了对持久化的支持，即将可以内存中的数据异步写入到硬盘中，同时不影响继续提供服务

• 功能丰富

缓存：为每个键设置生存时间（Time To Live，TTL），生存时间到期后键会自动被删除

队列：Redis的列表类型键可以用来实现队列，并且支持阻塞式读取，可以很容易地实现一个高性能的优先级队列

构建聊天室等系统：支持“发布/订阅”的消息模式

• 简单稳定

如何使用Redis

字符串

public void testString(){
    Jedis jedis = RedisUtil.connect();
    jedis.set("testKey", "testValue");
    System.out.println("testKey: " + jedis.get("testKey"));
    Long delResult = jedis.del("testKey");
    System.out.println("del testKey, result = " + delResult);
    System.out.println("del后，testKey: " + jedis.get("testKey"));
}

• 问题：字符串直接用char数组就好了，但是redis做了一些优化

目的：提高空间的利用率

方法：tryObjectEncoding包含的主要逻辑，依次执行以下策略

1. 判断长度小于20，且可以将它转换为long类型的值：int string2l(const char *s, size_t slen, long *lval)

2. 把value放在和与对象相同的内存块中：robj *createEmbeddedStringObject(const char *ptr, size_t len)

注：o对象（即返回结果）获得如下全部的内存空间，value是设置的值，与o对象分配在同一块中

3. 无法转换，把多分配的空间remove

列表

public void testList(){
    String testKey = "testKey";
    jedis.lpush(testKey, "testValue", "testValue2");
    System.out.println("testKey: " + jedis.lrange(testKey, 0, -1));
    jedis.lpush(testKey, "testValue", "testValue2", "testValue3");
    System.out.println("testKey set new: " + jedis.lrange(testKey, 0, -1));
    jedis.lrem(testKey, 2, "testValue");
    System.out.println("testKey lrem 2个数据后: " + jedis.lrange(testKey, 0, -1));
    Long delResult = jedis.del(testKey);
    System.out.println("del testKey, result = " + delResult);
    System.out.println("del后，testKey: " + jedis.get(testKey));
    System.out.println("del后，testKey: " + jedis.lrange(testKey, 0, -1));
}

集合

public void testSet(){
    String testKey = "testKey";
    jedis.sadd(testKey, "testValue", "testValue2");
    System.out.println("testKey: " + jedis.smembers(testKey));
    jedis.sadd(testKey, "testValue", "testValue2", "testValue3");
    System.out.println("testKey set new: " + jedis.smembers(testKey));
    jedis.srem(testKey, "testValue");
    System.out.println("testKey srem后: " + jedis.smembers(testKey));
}

有序集合

public void testSortedSet(){
    String testKey = "testKey";
    jedis.zadd(testKey, 5, "testValue5");
    jedis.zadd(testKey, 2, "testValue2");
    System.out.println("testKey: " + jedis.zrange(testKey, 0, -1));
    jedis.zadd(testKey, 2, "testValue2-2");
    jedis.zadd(testKey, 9, "testValue9");
    System.out.println("testKey zadd: " + jedis.zrange(testKey, 0, -1));
    jedis.zrem(testKey, "testValue2");
    System.out.println("testKey zrem后: " + jedis.zrange(testKey, 0, -1));
}

哈希

public void testHash(){
    String testKey = "testKey";
    jedis.hset(testKey, "field", "100");
    System.out.println("testKey: " + jedis.hget(testKey, "field"));
    jedis.hincrBy(testKey, "field", 100);
    System.out.println("testKey 的value hincrBy: " + jedis.hvals(testKey));

    jedis.hset(testKey, "field", "testValue");
    jedis.hset(testKey, "field2", "testValue2");
    jedis.hset(testKey, "field3", "testValue3");
    System.out.println("testKey new hset, keys= " + jedis.hkeys(testKey));
    System.out.println("testKey new hset, values= " + jedis.hvals(testKey));
    jedis.hdel(testKey, "field3");
    System.out.println("testKey hdel, keys= " + jedis.hkeys(testKey));
    System.out.println("testKey hdel, values= " + jedis.hvals(testKey));
}

底层数据结构

/*3个基础数据结构 */
typedef struct dict {
    dictType *type;
    void *privdata;
    dictht ht[2];// 有两个table
    long rehashidx; 
    unsigned long iterators;
} dict;

/* hash table结构 */
typedef struct dictht {
    dictEntry **table;
    unsigned long size;
    unsigned long sizemask;
    unsigned long used;
} dictht;

/* 节点结构*/
typedef struct dictEntry {
    void *key;
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    struct dictEntry *next;
} dictEntry;


/* 
* 根据key查找entry 
* key 通过hash获取index，冲突则通过挂链方式继续查找
*/
dictEntry *dictFind(dict *d, const void *key)
{
    dictEntry *he;
    uint64_t h, idx, table;

    if (d->ht[0].used + d->ht[1].used == 0) return NULL; /* dict is empty */
    if (dictIsRehashing(d)) _dictRehashStep(d);
    h = dictHashKey(d, key);
    for (table = 0; table <= 1; table++) {
        idx = h & d->ht[table].sizemask;
        he = d->ht[table].table[idx];
        while (he) {//遍历该位置下所有key
            if (key == he->key || dictCompareKeys(d, key, he->key))
                return he;
            he = he->next;
        }
        if (!dictIsRehashing(d)) return NULL;
    }
    return NULL;
}

/* 创建dict，初始化时dictht大小为0 */
dict *dictCreate(dictType *type,
    void *privDataPtr)
{
    dict *d = zmalloc(sizeof(*d));

    _dictInit(d, type, privDataPtr);
    return d;
}

/* 扩展或创建dictht */
int dictExpand(dict *d, unsigned long size)
{
    /* the size is invalid if it is smaller than the number of
    * elements already inside the hash table */
    if (dictIsRehashing(d) || d->ht[0].used > size)
        return DICT_ERR;

    dictht n; /* the new hash table */
        /* 获取要分配的dictht的大小 */
    unsigned long realsize = _dictNextPower(size);

    /* Rehashing to the same table size is not useful. */
    if (realsize == d->ht[0].size) return DICT_ERR;

    /* Allocate the new hash table and initialize all pointers to NULL */
    n.size = realsize;
    n.sizemask = realsize - 1;
    n.table = zcalloc(realsize*sizeof(dictEntry*));
    n.used = 0;

    /* Is this the first initialization? If so it's not really a rehashing
    * we just set the first hash table so that it can accept keys. */
    if (d->ht[0].table == NULL) {
        d->ht[0] = n;
        return DICT_OK;
    }

    /* Prepare a second hash table for incremental rehashing */
    d->ht[1] = n;
    d->rehashidx = 0;
    return DICT_OK;
}

/* 
* hash table的容量为2的幂
* 初始化大小为4
*/
static unsigned long _dictNextPower(unsigned long size)
{
    unsigned long i = DICT_HT_INITIAL_SIZE;

    if (size >= LONG_MAX) return LONG_MAX + 1LU;
    while (1) {
        if (i >= size)
            return i;
        i *= 2;
    }
}

/* 添加一个kv */
dictEntry *dictAddRaw(dict *d, void *key, dictEntry **existing)
{
    long index;
    dictEntry *entry;
    dictht *ht;

    if (dictIsRehashing(d)) _dictRehashStep(d);

    /* Get the index of the new element, or -1 if
    * the element already exists. */
    if ((index = _dictKeyIndex(d, key, dictHashKey(d, key), existing)) == -1)
        return NULL;

    /* 最新的kv放在链表的第一个，该kv最可能被访问到*/
    ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
    entry = zmalloc(sizeof(*entry));
    entry->next = ht->table[index];
    ht->table[index] = entry;
    ht->used++;

    /* Set the hash entry fields. */
    dictSetKey(d, entry, key);
    return entry;
}