// 多線程模式下的偽代碼
public class MultiThreadRedis {
    private final Object lock = new Object();
    private Map<String, String> data = new HashMap<>();
    
    public String get(String key) {
        synchronized(lock) {  // 需要加鎖
            return data.get(key);
        }
    }
    
    public void set(String key, String value) {
        synchronized(lock) {  // 需要加鎖
            data.put(key, value);
        }
    }
}

// Redis單線程模式下的偽代碼
public class SingleThreadRedis {
    private Map<String, String> data = new HashMap<>();
    
    public String get(String key) {
        return data.get(key);  // 無需加鎖
    }
    
    public void set(String key, String value) {
        data.put(key, value);  // 無需加鎖
    }
}

// Redis SDS結(jié)構(gòu)
struct sdshdr {
    int len;        // 字符串長度
    int free;       // 未使用空間長度
    char buf[];     // 字符串內(nèi)容
};

// 跳躍表查找偽代碼
public Node search(int target) {
    Node current = header;
    
    // 從最高層開始查找
    for (int level = maxLevel; level >= 0; level--) {
        // 在當(dāng)前層向右移動，直到下一個節(jié)點大于目標(biāo)值
        while (current.forward[level] != null && 
               current.forward[level].value < target) {
            current = current.forward[level];
        }
    }
    
    // 移動到下一個節(jié)點
    current = current.forward[0];
    
    if (current != null && current.value == target) {
        return current;
    }
    returnnull;
}

// 整數(shù)集合結(jié)構(gòu)
typedef struct intset {
    uint32_t encoding;  // 編碼方式
    uint32_t length;    // 元素數(shù)量
    int8_t contents[];  // 元素數(shù)組
} intset;

// 整數(shù)集合編碼升級示例
public class IntSetExample {
    // 初始狀態(tài)：所有元素都是16位整數(shù)
    // encoding = INTSET_ENC_INT16
    // contents = [1, 2, 3, 4, 5]
    
    // 添加一個32位整數(shù)
    public void addLargeNumber() {
        // 自動升級為32位編碼
        // encoding = INTSET_ENC_INT32
        // 重新分配內(nèi)存，轉(zhuǎn)換所有現(xiàn)有元素
    }
}

# redis.conf配置
# 普通客戶端緩沖區(qū)限制
client-output-buffer-limit normal 0 0 0

# 從服務(wù)器緩沖區(qū)限制  
client-output-buffer-limit replica 256mb 64mb 60

# 發(fā)布訂閱客戶端緩沖區(qū)限制
client-output-buffer-limit pubsub 32mb 8mb 60

// Redis定期刪除偽代碼
public void activeExpireCycle() {
    int maxIterations = 16; // 最大檢查數(shù)據(jù)庫數(shù)
    int maxChecks = 20;     // 每個數(shù)據(jù)庫最大檢查鍵數(shù)
    
    for (int i = 0; i < maxIterations; i++) {
        RedisDb db = server.db[i];
        int expired = 0;
        
        for (int j = 0; j < maxChecks; j++) {
            String key = db.expires.randomKey();
            if (key != null && isExpired(key)) {
                deleteKey(key);
                expired++;
            }
        }
        
        // 如果過期鍵比例小于25%，跳出循環(huán)
        if (expired < maxChecks / 4) {
            break;
        }
    }
}

// AOF重寫示例
public class AOFRewrite {
    // 原始AOF文件可能包含：
    // SET key1 value1
    // SET key1 value2  
    // SET key1 value3
    // DEL key2
    // SET key2 newvalue
    // LPUSH list a
    // LPUSH list b
    // LPUSH list c
    
    // 重寫后的AOF文件：
    // SET key1 value3
    // SET key2 newvalue  
    // LPUSH list c b a
    
    public void rewriteAOF() {
        // 遍歷所有數(shù)據(jù)庫
        for (RedisDb db : server.databases) {
            // 遍歷所有鍵
            for (String key : db.dict.keys()) {
                Object value = db.dict.get(key);
                // 根據(jù)值的類型生成對應(yīng)的命令
                generateCommand(key, value);
            }
        }
    }
}

public class RedisClusterSlot {
    private static final int CLUSTER_SLOTS = 16384;
    
    public int calculateSlot(String key) {
        // 檢查是否有哈希標(biāo)簽
        int start = key.indexOf('{');
        if (start != -1) {
            int end = key.indexOf('}', start + 1);
            if (end != -1 && end != start + 1) {
                key = key.substring(start + 1, end);
            }
        }
        
        // 計算CRC16校驗和
        int crc = crc16(key.getBytes());
        return crc % CLUSTER_SLOTS;
    }
    
    // CRC16算法實現(xiàn)
    private int crc16(byte[] data) {
        int crc = 0x0000;
        for (byte b : data) {
            crc ^= (b & 0xFF);
            for (int i = 0; i < 8; i++) {
                if ((crc & 0x0001) != 0) {
                    crc = (crc >> 1) ^ 0xA001;
                } else {
                    crc = crc >> 1;
                }
            }
        }
        return crc & 0xFFFF;
    }
}

# 查看Redis信息
INFO all

# 監(jiān)控實時命令
MONITOR

# 查看慢查詢?nèi)罩?SLOWLOG GET 10

# 查看客戶端連接
CLIENT LIST

# 查看內(nèi)存使用情況
MEMORY USAGE keyname

# 查看延遲統(tǒng)計
LATENCY LATEST

# redis.conf優(yōu)化配置

# 啟用內(nèi)存壓縮
hash-max-ziplist-entries 512
hash-max-ziplist-value 64

list-max-ziplist-size -2
list-compress-depth 0

set-max-intset-entries 512

zset-max-ziplist-entries 128
zset-max-ziplist-value 64

# 內(nèi)存淘汰策略
maxmemory-policy allkeys-lru

# 啟用內(nèi)存壓縮
rdbcompression yes

# TCP相關(guān)優(yōu)化
tcp-keepalive 300
tcp-backlog 511

# 客戶端超時
timeout 0

# 輸出緩沖區(qū)限制
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60

// Redis主從復(fù)制流程
public class RedisReplication {
    
    // 全量同步
    public void fullResync() {
        // 1. 從服務(wù)器發(fā)送PSYNC命令
        // 2. 主服務(wù)器執(zhí)行BGSAVE生成RDB文件
        // 3. 主服務(wù)器將RDB文件發(fā)送給從服務(wù)器
        // 4. 從服務(wù)器載入RDB文件
        // 5. 主服務(wù)器將緩沖區(qū)的寫命令發(fā)送給從服務(wù)器
    }
    
    // 增量同步
    public void partialResync() {
        // 1. 從服務(wù)器發(fā)送PSYNC runid offset
        // 2. 主服務(wù)器檢查復(fù)制偏移量
        // 3. 如果偏移量在復(fù)制積壓緩沖區(qū)內(nèi)，執(zhí)行增量同步
        // 4. 主服務(wù)器將緩沖區(qū)中的數(shù)據(jù)發(fā)送給從服務(wù)器
    }
}