What are common Redis problems? How to solve these problems? - 面试题

Redis encounters various common problems during use. Understanding these problems and their solutions is crucial for ensuring Redis stability and performance.

1. Why is Redis so fast?

Reason Analysis

Memory-based Storage:

Redis stores all data in memory, memory read/write speed is much faster than disk
Memory access time is in nanoseconds, while disk access time is in milliseconds

Single-threaded Model:

Redis uses a single-threaded model to process commands, avoiding context switching and lock contention of multi-threading
Single-threaded model simplifies implementation and reduces concurrency issues

I/O Multiplexing:

Redis uses I/O multiplexing model (epoll, kqueue, select), can handle multiple client connections simultaneously
I/O multiplexing avoids blocking and improves concurrent processing capability

Efficient Data Structures:

Redis uses efficient data structures such as SDS, skip lists, compressed lists, etc.
These data structures are optimized for specific scenarios, improving operation efficiency

Optimized Command Execution:

Redis command execution is highly optimized, reducing unnecessary operations
Uses batch operations (Pipeline) to reduce network round trips

2. Why did Redis choose single-threading?

Advantages

Avoid Context Switching:

Multi-threading requires frequent context switching, consuming CPU resources
Single-threading avoids context switching, improving CPU utilization

Avoid Lock Contention:

Multi-threading needs locks to ensure data consistency, lock contention reduces performance
Single-threading doesn't need locks, avoiding performance loss from lock contention

Simplify Implementation:

Single-threaded model simplifies implementation, reducing complexity of concurrency issues
Code is easier to maintain and debug

Memory Friendly:

Single-threaded model is more friendly to CPU cache, improving cache hit rate

Why is single-threading still high performance?

Redis bottleneck is not in CPU:

Redis bottleneck is mainly in network I/O and memory access, not CPU
Single thread is sufficient to handle network I/O and memory access

I/O Multiplexing:

Redis uses I/O multiplexing, can handle multiple client connections simultaneously
Single thread can efficiently handle multiple connections

Memory-based:

Redis is memory-based, memory access speed is extremely fast
Single thread can fully leverage memory's high performance

Multi-threaded Redis

Redis 6.0 introduced multi-threading, mainly for network I/O read/write:

Network I/O multi-threading: Network I/O read/write uses multi-threading, improving network processing capability
Command execution single-threading: Command execution still uses single-threading, ensuring data consistency

3. How does Redis ensure data consistency?

Cache Consistency

Problem:

Cache and database data inconsistency, leading to reading dirty data

Solutions:

Solution 1: Cache Aside Pattern

java
// Read operation
public User getUserById(Long id) {
    User user = redis.get("user:" + id);
    if (user != null) {
        return user;
    }
    user = db.queryUserById(id);
    redis.set("user:" + id, user, 3600);
    return user;
}

// Write operation
public void updateUser(User user) {
    db.updateUser(user);
    redis.del("user:" + user.getId());
}

Solution 2: Delayed Double Delete

java
public void updateUser(User user) {
    db.updateUser(user);
    redis.del("user:" + user.getId()); // First delete
    
    try {
        Thread.sleep(500); // Delay
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    
    redis.del("user:" + user.getId()); // Second delete
}

Solution 3: Subscribe to Binlog

java
// Subscribe to database Binlog, automatically update cache when database changes
@CanalEventListener
public class CacheUpdateListener {
    
    @ListenPoint(destination = "example", schema = "test", table = "user")
    public void onEvent(CanalEntry.Entry entry) {
        // Parse Binlog, update cache
        User user = parseUserFromBinlog(entry);
        redis.set("user:" + user.getId(), user, 3600);
    }
}

Master-Slave Consistency

Problem:

Master-slave replication has latency, leading to reading old data from slaves

Solutions:

Solution 1: Read-Write Separation

java
// Write operation uses master
public void updateUser(User user) {
    masterRedis.set("user:" + user.getId(), user);
}

// Read operation uses slave
public User getUserById(Long id) {
    return slaveRedis.get("user:" + id);
}

Solution 2: Force Read from Master

java
// For data requiring strong consistency, force read from master
public User getUserByIdWithConsistency(Long id) {
    return masterRedis.get("user:" + id);
}

4. How does Redis handle big keys?

Dangers of Big Keys

High Memory Usage:

Big keys occupy large amounts of memory, affecting storage of other data

Performance Issues:

Read/write operations on big keys take longer, affecting Redis performance
Delete operations on big keys block Redis, causing other requests to wait

Slow Master-Slave Sync:

Master-slave sync of big keys takes longer, affecting master-slave sync efficiency

Solutions

Solution 1: Split Big Keys

java
// Split big key into multiple small keys
public void setBigKey(String key, String value) {
    int chunkSize = 1024; // Each chunk is 1KB
    for (int i = 0; i < value.length(); i += chunkSize) {
        String chunk = value.substring(i, Math.min(i + chunkSize, value.length()));
        redis.set(key + ":" + i, chunk);
    }
}

public String getBigKey(String key) {
    StringBuilder sb = new StringBuilder();
    int i = 0;
    while (true) {
        String chunk = redis.get(key + ":" + i);
        if (chunk == null) {
            break;
        }
        sb.append(chunk);
        i++;
    }
    return sb.toString();
}

Solution 2: Use Hash

java
// Use Hash to store big objects
public void setBigObject(String key, Map<String, String> data) {
    for (Map.Entry<String, String> entry : data.entrySet()) {
        redis.hset(key, entry.getKey(), entry.getValue());
    }
}

public Map<String, String> getBigObject(String key) {
    return redis.hgetAll(key);
}

Solution 3: Async Delete

java
// Use UNLINK command to asynchronously delete big keys
public void deleteBigKey(String key) {
    redis.unlink(key); // Async delete, won't block Redis
}

5. How does Redis handle hot keys?

Dangers of Hot Keys

Single Node Pressure:

Hot keys concentrate on a certain node, causing excessive pressure on that node

Performance Bottleneck:

Hot keys have excessive access volume, causing performance bottleneck

Solutions

Solution 1: Read-Write Separation

java
// Read operation uses slave
public User getUserById(Long id) {
    return slaveRedis.get("user:" + id);
}

Solution 2: Local Cache

java
// Use local cache to reduce Redis access
public User getUserById(Long id) {
    // First check local cache
    User user = localCache.get("user:" + id);
    if (user != null) {
        return user;
    }
    
    // Then check Redis
    user = redis.get("user:" + id);
    if (user != null) {
        localCache.put("user:" + id, user);
    }
    
    return user;
}

Solution 3: Hot Key Sharding

java
// Split hot key into multiple keys
public void setHotKey(String key, String value) {
    int shardCount = 10;
    for (int i = 0; i < shardCount; i++) {
        redis.set(key + ":" + i, value);
    }
}

public String getHotKey(String key) {
    int shard = (int) (Math.random() * 10);
    return redis.get(key + ":" + shard);
}

6. How does Redis implement distributed locks?

Implementation Methods

Solution 1: SET NX EX

java
public boolean tryLock(String key, String value, int expireTime) {
    String result = redis.set(key, value, "NX", "EX", expireTime);
    return "OK".equals(result);
}

public void unlock(String key, String value) {
    String script = "if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end";
    redis.eval(script, Collections.singletonList(key), Collections.singletonList(value));
}

Solution 2: Redlock

java
public boolean tryLock(String key, String value, int expireTime) {
    int successCount = 0;
    for (RedisClient client : redisClients) {
        if (client.set(key, value, "NX", "EX", expireTime).equals("OK")) {
            successCount++;
        }
    }
    return successCount > redisClients.size() / 2;
}

Solution 3: Redisson

java
public void doWithLock(String lockKey, Runnable task) {
    RLock lock = redisson.getLock(lockKey);
    try {
        lock.lock();
        task.run();
    } finally {
        lock.unlock();
    }
}

7. How does Redis implement rate limiting?

Implementation Methods

Solution 1: Fixed Window

java
public boolean allowRequest(String key, int limit, int expireTime) {
    String count = redis.get(key);
    if (count == null) {
        redis.set(key, "1", expireTime);
        return true;
    }
    int currentCount = Integer.parseInt(count);
    if (currentCount < limit) {
        redis.incr(key);
        return true;
    }
    return false;
}

Solution 2: Sliding Window

java
public boolean allowRequestSliding(String key, int limit, int windowSize) {
    long currentTime = System.currentTimeMillis();
    long windowStart = currentTime - windowSize;
    redis.zremrangeByScore(key, 0, windowStart);
    redis.zadd(key, currentTime, UUID.randomUUID().toString());
    long count = redis.zcard(key);
    return count <= limit;
}

Solution 3: Token Bucket

java
public boolean allowRequestTokenBucket(String key, int capacity, int rate) {
    String script = "local tokens = tonumber(redis.call('get', KEYS[1])) or 0" +
                  "tokens = math.min(tokens + ARGV[1], ARGV[2])" +
                  "if tokens >= 1 then" +
                  "  redis.call('set', KEYS[1], tokens - 1)" +
                  "  return 1" +
                  "else" +
                  "  redis.call('set', KEYS[1], tokens)" +
                  "  return 0" +
                  "end";
    return redis.eval(script, Collections.singletonList(key), Collections.singletonList(rate), Collections.singletonList(capacity)) == 1;
}

Summary

Redis encounters various common problems during use, including performance issues, consistency issues, big key issues, hot key issues, etc. Understanding these problems and their solutions is crucial for ensuring Redis stability and performance. In actual applications, appropriate solutions need to be selected based on specific business scenarios.