第23集Redis单实例QPS可达10万是什么情况

// QPS基础概念解释
public class QPSConcept {
    
    /**
     * QPS = Queries Per Second（每秒查询数）
     * 简单理解：1秒钟内能处理多少个请求
     */
    public static void explainQPS() {
        System.out.println("=== QPS基础概念 ===");
        System.out.println("QPS = Queries Per Second（每秒查询数）");
        System.out.println("简单理解：1秒钟内能处理多少个请求");
        System.out.println();
        
        System.out.println("举例说明：");
        System.out.println("• 如果QPS = 1000，表示1秒能处理1000个请求");
        System.out.println("• 如果QPS = 10000，表示1秒能处理10000个请求");
        System.out.println("• 如果QPS = 100000，表示1秒能处理100000个请求");
        System.out.println();
        
        System.out.println("时间换算：");
        System.out.println("• 100000 QPS = 每秒10万次请求");
        System.out.println("• 平均每个请求耗时 = 1秒 ÷ 100000 = 0.01毫秒");
        System.out.println("• 也就是说，每个请求只需要0.01毫秒就能完成！");
    }
    
    /**
     * QPS计算示例
     */
    public static void calculateQPS() {
        System.out.println("\n=== QPS计算示例 ===");
        
        // 假设场景：电商网站秒杀活动
        int totalRequests = 1000000; // 总请求数：100万
        int timeSeconds = 10;       // 时间：10秒
        
        int qps = totalRequests / timeSeconds;
        
        System.out.println("场景：电商网站秒杀活动");
        System.out.println("总请求数：" + totalRequests + " 个");
        System.out.println("时间：" + timeSeconds + " 秒");
        System.out.println("QPS = " + totalRequests + " ÷ " + timeSeconds + " = " + qps);
        System.out.println("平均每秒处理 " + qps + " 个请求");
        
        // 计算平均响应时间
        double avgResponseTime = 1000.0 / qps; // 毫秒
        System.out.println("平均响应时间 = 1000毫秒 ÷ " + qps + " = " + String.format("%.2f", avgResponseTime) + " 毫秒");
    }
}

// QPS与系统性能的关系
public class QPSPerformanceRelation {
    
    /**
     * 不同QPS级别的系统性能对比
     */
    public static void compareQPSLevels() {
        System.out.println("=== 不同QPS级别的系统性能对比 ===");
        
        System.out.println("1. 低QPS系统（< 1000 QPS）：");
        System.out.println("   - 典型应用：小型网站、个人博客");
        System.out.println("   - 特点：用户量少，请求简单");
        System.out.println("   - 技术栈：单机部署，简单架构");
        
        System.out.println("\n2. 中等QPS系统（1000 - 10000 QPS）：");
        System.out.println("   - 典型应用：中型电商网站、企业系统");
        System.out.println("   - 特点：有一定用户量，需要优化");
        System.out.println("   - 技术栈：负载均衡，数据库优化");
        
        System.out.println("\n3. 高QPS系统（10000 - 100000 QPS）：");
        System.out.println("   - 典型应用：大型电商、社交平台");
        System.out.println("   - 特点：用户量大，需要高性能");
        System.out.println("   - 技术栈：分布式架构，缓存优化");
        
        System.out.println("\n4. 超高QPS系统（> 100000 QPS）：");
        System.out.println("   - 典型应用：秒杀系统、实时游戏");
        System.out.println("   - 特点：瞬时高并发，需要极致性能");
        System.out.println("   - 技术栈：内存数据库，CDN加速");
    }
    
    /**
     * QPS对用户体验的影响
     */
    public static void explainUserExperience() {
        System.out.println("\n=== QPS对用户体验的影响 ===");
        
        System.out.println("响应时间与QPS的关系：");
        System.out.println("• QPS越高，平均响应时间越短");
        System.out.println("• 响应时间越短，用户体验越好");
        System.out.println();
        
        System.out.println("用户体验标准：");
        System.out.println("• < 100ms：用户感觉非常快");
        System.out.println("• 100-300ms：用户感觉快");
        System.out.println("• 300-1000ms：用户感觉一般");
        System.out.println("• > 1000ms：用户感觉慢");
        System.out.println();
        
        System.out.println("Redis 10万QPS意味着：");
        System.out.println("• 平均响应时间 = 1000ms ÷ 100000 = 0.01ms");
        System.out.println("• 这个速度比人眼能感知的最快速度还要快！");
        System.out.println("• 用户几乎感觉不到任何延迟");
    }
}

// Redis高性能核心原理
public class RedisHighPerformance {
    
    /**
     * Redis高性能的5大核心原理
     */
    public static void explainCorePrinciples() {
        System.out.println("=== Redis高性能的5大核心原理 ===");
        
        System.out.println("1. 内存存储（Memory Storage）");
        System.out.println("   - 数据存储在内存中，不是磁盘");
        System.out.println("   - 内存访问速度比磁盘快1000倍以上");
        System.out.println("   - 类比：从书桌上拿书 vs 从图书馆找书");
        
        System.out.println("\n2. 单线程模型（Single Thread）");
        System.out.println("   - Redis主线程只有一个，避免线程切换开销");
        System.out.println("   - 没有锁竞争，没有上下文切换");
        System.out.println("   - 类比：一个熟练的厨师 vs 多个新手厨师");
        
        System.out.println("\n3. 高效数据结构（Efficient Data Structures）");
        System.out.println("   - 专门优化的数据结构（SDS、跳跃表等）");
        System.out.println("   - 时间复杂度低，操作简单");
        System.out.println("   - 类比：专业工具 vs 通用工具");
        
        System.out.println("\n4. 网络I/O优化（Network I/O Optimization）");
        System.out.println("   - 使用epoll多路复用技术");
        System.out.println("   - 非阻塞I/O，高并发处理");
        System.out.println("   - 类比：多窗口同时服务 vs 单窗口排队");
        
        System.out.println("\n5. 协议简单（Simple Protocol）");
        System.out.println("   - Redis协议简单，解析快速");
        System.out.println("   - 减少CPU消耗");
        System.out.println("   - 类比：简单指令 vs 复杂指令");
    }
    
    /**
     * 内存 vs 磁盘性能对比
     */
    public static void compareMemoryDisk() {
        System.out.println("\n=== 内存 vs 磁盘性能对比 ===");
        
        System.out.println("访问速度对比：");
        System.out.println("• 内存访问：约100纳秒");
        System.out.println("• SSD访问：约100微秒");
        System.out.println("• 机械硬盘：约10毫秒");
        System.out.println();
        
        System.out.println("速度倍数关系：");
        System.out.println("• 内存比SSD快：1000倍");
        System.out.println("• 内存比机械硬盘快：100000倍");
        System.out.println();
        
        System.out.println("实际应用场景：");
        System.out.println("• 数据库查询（磁盘）：10-100ms");
        System.out.println("• Redis查询（内存）：0.01-0.1ms");
        System.out.println("• Redis比数据库快：100-1000倍");
    }
}

// Redis单线程模型优势
public class RedisSingleThreadAdvantages {
    
    /**
     * 单线程模型的优势
     */
    public static void explainAdvantages() {
        System.out.println("=== Redis单线程模型的优势 ===");
        
        System.out.println("1. 避免线程切换开销");
        System.out.println("   - 多线程需要频繁切换上下文");
        System.out.println("   - 单线程没有切换开销");
        System.out.println("   - 类比：一个人专心做一件事 vs 多个人轮流做");
        
        System.out.println("\n2. 避免锁竞争");
        System.out.println("   - 多线程需要加锁保护共享数据");
        System.out.println("   - 单线程不需要锁，没有竞争");
        System.out.println("   - 类比：一个人用厕所 vs 多个人抢厕所");
        
        System.out.println("\n3. 简化实现");
        System.out.println("   - 代码逻辑简单，易于维护");
        System.out.println("   - 没有复杂的同步机制");
        System.out.println("   - 类比：简单规则 vs 复杂规则");
        
        System.out.println("\n4. 充分利用CPU缓存");
        System.out.println("   - 单线程数据局部性好");
        System.out.println("   - CPU缓存命中率高");
        System.out.println("   - 类比：连续访问 vs 随机访问");
    }
    
    /**
     * 单线程模型的局限性
     */
    public static void explainLimitations() {
        System.out.println("\n=== 单线程模型的局限性 ===");
        
        System.out.println("1. 无法利用多核CPU");
        System.out.println("   - 只能使用一个CPU核心");
        System.out.println("   - 多核CPU资源浪费");
        System.out.println("   - 解决方案：Redis Cluster多实例部署");
        
        System.out.println("\n2. 大键操作阻塞");
        System.out.println("   - 大键操作会阻塞其他请求");
        System.out.println("   - 影响整体性能");
        System.out.println("   - 解决方案：避免大键，分片存储");
        
        System.out.println("\n3. 复杂计算影响性能");
        System.out.println("   - 复杂计算会占用大量时间");
        System.out.println("   - 影响其他请求处理");
        System.out.println("   - 解决方案：异步处理，计算分离");
    }
}

// Redis性能测试工具
@Service
public class RedisPerformanceTest {
    
    private static final Logger logger = LoggerFactory.getLogger(RedisPerformanceTest.class);
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    /**
     * 基础性能测试
     */
    public void basicPerformanceTest() {
        logger.info("开始Redis基础性能测试...");
        
        int testCount = 100000; // 测试10万次操作
        long startTime = System.currentTimeMillis();
        
        // 执行测试
        for (int i = 0; i < testCount; i++) {
            String key = "test:key:" + i;
            String value = "test:value:" + i;
            
            // SET操作
            redisTemplate.opsForValue().set(key, value);
            
            // GET操作
            String result = redisTemplate.opsForValue().get(key);
            
            // 验证结果
            if (!value.equals(result)) {
                logger.error("测试失败：值不匹配");
                return;
            }
        }
        
        long endTime = System.currentTimeMillis();
        long totalTime = endTime - startTime;
        
        // 计算QPS
        double qps = (testCount * 2.0) / (totalTime / 1000.0); // 每次循环包含SET和GET两个操作
        
        logger.info("=== Redis基础性能测试结果 ===");
        logger.info("测试操作数：{} 次（SET + GET）", testCount * 2);
        logger.info("总耗时：{} 毫秒", totalTime);
        logger.info("QPS：{:.2f}", qps);
        logger.info("平均响应时间：{:.4f} 毫秒", totalTime / (testCount * 2.0));
    }
    
    /**
     * 不同数据类型的性能测试
     */
    public void dataTypePerformanceTest() {
        logger.info("开始Redis数据类型性能测试...");
        
        int testCount = 10000;
        
        // String类型测试
        testStringOperations(testCount);
        
        // Hash类型测试
        testHashOperations(testCount);
        
        // List类型测试
        testListOperations(testCount);
        
        // Set类型测试
        testSetOperations(testCount);
    }
    
    /**
     * String类型操作测试
     */
    private void testStringOperations(int testCount) {
        logger.info("测试String类型操作...");
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < testCount; i++) {
            String key = "string:test:" + i;
            String value = "string:value:" + i;
            
            redisTemplate.opsForValue().set(key, value);
            redisTemplate.opsForValue().get(key);
        }
        
        long endTime = System.currentTimeMillis();
        double qps = (testCount * 2.0) / ((endTime - startTime) / 1000.0);
        
        logger.info("String类型QPS：{:.2f}", qps);
    }
    
    /**
     * Hash类型操作测试
     */
    private void testHashOperations(int testCount) {
        logger.info("测试Hash类型操作...");
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < testCount; i++) {
            String key = "hash:test:" + i;
            String field = "field" + i;
            String value = "hash:value:" + i;
            
            redisTemplate.opsForHash().put(key, field, value);
            redisTemplate.opsForHash().get(key, field);
        }
        
        long endTime = System.currentTimeMillis();
        double qps = (testCount * 2.0) / ((endTime - startTime) / 1000.0);
        
        logger.info("Hash类型QPS：{:.2f}", qps);
    }
    
    /**
     * List类型操作测试
     */
    private void testListOperations(int testCount) {
        logger.info("测试List类型操作...");
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < testCount; i++) {
            String key = "list:test:" + i;
            String value = "list:value:" + i;
            
            redisTemplate.opsForList().leftPush(key, value);
            redisTemplate.opsForList().leftPop(key);
        }
        
        long endTime = System.currentTimeMillis();
        double qps = (testCount * 2.0) / ((endTime - startTime) / 1000.0);
        
        logger.info("List类型QPS：{:.2f}", qps);
    }
    
    /**
     * Set类型操作测试
     */
    private void testSetOperations(int testCount) {
        logger.info("测试Set类型操作...");
        
        long startTime = System.currentTimeMillis();
        
        for (int i = 0; i < testCount; i++) {
            String key = "set:test:" + i;
            String value = "set:value:" + i;
            
            redisTemplate.opsForSet().add(key, value);
            redisTemplate.opsForSet().isMember(key, value);
        }
        
        long endTime = System.currentTimeMillis();
        double qps = (testCount * 2.0) / ((endTime - startTime) / 1000.0);
        
        logger.info("Set类型QPS：{:.2f}", qps);
    }
}

// 性能测试结果分析
public class PerformanceAnalysis {
    
    /**
     * 分析Redis性能测试结果
     */
    public static void analyzeResults() {
        System.out.println("=== Redis性能测试结果分析 ===");
        
        System.out.println("1. 基础操作性能：");
        System.out.println("   - SET操作：约100,000 QPS");
        System.out.println("   - GET操作：约100,000 QPS");
        System.out.println("   - 平均响应时间：0.01毫秒");
        
        System.out.println("\n2. 不同数据类型性能对比：");
        System.out.println("   - String类型：100,000 QPS（最快）");
        System.out.println("   - Hash类型：80,000 QPS");
        System.out.println("   - List类型：60,000 QPS");
        System.out.println("   - Set类型：70,000 QPS");
        
        System.out.println("\n3. 性能影响因素：");
        System.out.println("   - 数据大小：数据越大，性能越低");
        System.out.println("   - 操作复杂度：复杂操作性能较低");
        System.out.println("   - 网络延迟：网络延迟影响整体性能");
        System.out.println("   - 服务器配置：CPU、内存配置影响性能");
        
        System.out.println("\n4. 实际应用中的QPS：");
        System.out.println("   - 理论QPS：100,000+");
        System.out.println("   - 实际QPS：50,000-80,000");
        System.out.println("   - 影响因素：网络、业务逻辑、数据大小");
    }
    
    /**
     * 性能优化建议
     */
    public static void optimizationSuggestions() {
        System.out.println("\n=== Redis性能优化建议 ===");
        
        System.out.println("1. 数据结构优化：");
        System.out.println("   - 选择合适的数据类型");
        System.out.println("   - 避免大键操作");
        System.out.println("   - 使用批量操作");
        
        System.out.println("\n2. 网络优化：");
        System.out.println("   - 使用连接池");
        System.out.println("   - 减少网络往返");
        System.out.println("   - 使用管道技术");
        
        System.out.println("\n3. 配置优化：");
        System.out.println("   - 调整内存配置");
        System.out.println("   - 优化持久化策略");
        System.out.println("   - 调整网络参数");
        
        System.out.println("\n4. 架构优化：");
        System.out.println("   - 读写分离");
        System.out.println("   - 分片存储");
        System.out.println("   - 集群部署");
    }
}

// 高QPS应用场景
public class HighQPSApplications {
    
    /**
     * 高QPS应用场景分析
     */
    public static void analyzeScenarios() {
        System.out.println("=== 高QPS应用场景分析 ===");
        
        System.out.println("1. 电商秒杀系统：");
        System.out.println("   - QPS需求：50,000-100,000");
        System.out.println("   - 特点：瞬时高并发，数据一致性要求高");
        System.out.println("   - Redis作用：库存扣减，防重复购买");
        System.out.println("   - 技术方案：Redis + Lua脚本");
        
        System.out.println("\n2. 实时游戏系统：");
        System.out.println("   - QPS需求：30,000-80,000");
        System.out.println("   - 特点：低延迟，实时性要求高");
        System.out.println("   - Redis作用：玩家状态，游戏数据缓存");
        System.out.println("   - 技术方案：Redis + 内存优化");
        
        System.out.println("\n3. 社交平台：");
        System.out.println("   - QPS需求：20,000-50,000");
        System.out.println("   - 特点：读写频繁，数据量大");
        System.out.println("   - Redis作用：用户信息，动态缓存");
        System.out.println("   - 技术方案：Redis + 分片存储");
        
        System.out.println("\n4. 金融交易系统：");
        System.out.println("   - QPS需求：10,000-30,000");
        System.out.println("   - 特点：数据准确性要求高，低延迟");
        System.out.println("   - Redis作用：交易缓存，风控数据");
        System.out.println("   - 技术方案：Redis + 持久化");
    }
    
    /**
     * 秒杀系统Redis应用示例
     */
    public static class SeckillSystem {
        
        /**
         * 秒杀库存扣减
         */
        public boolean deductStock(String productId, int quantity) {
            String key = "seckill:stock:" + productId;
            
            // 使用Lua脚本保证原子性
            String luaScript = 
                "local stock = redis.call('get', KEYS[1]) " +
                "if stock == false then " +
                "    return 0 " +
                "end " +
                "if tonumber(stock) >= tonumber(ARGV[1]) then " +
                "    redis.call('decrby', KEYS[1], ARGV[1]) " +
                "    return 1 " +
                "else " +
                "    return 0 " +
                "end";
            
            // 执行Lua脚本
            Long result = redisTemplate.execute(
                (RedisCallback<Long>) connection -> 
                    connection.eval(luaScript.getBytes(), 
                        ReturnType.INTEGER, 1, 
                        key.getBytes(), 
                        String.valueOf(quantity).getBytes())
            );
            
            return result != null && result == 1;
        }
        
        /**
         * 防重复购买
         */
        public boolean checkDuplicatePurchase(String userId, String productId) {
            String key = "seckill:user:" + userId + ":" + productId;
            
            // 设置过期时间，防止重复购买
            Boolean result = redisTemplate.opsForValue().setIfAbsent(key, "1", Duration.ofMinutes(30));
            
            return result != null && result;
        }
        
        /**
         * 获取秒杀结果
         */
        public String getSeckillResult(String userId, String productId) {
            String key = "seckill:result:" + userId + ":" + productId;
            return redisTemplate.opsForValue().get(key);
        }
    }
}

// 性能监控和调优
@Service
public class RedisPerformanceMonitor {
    
    private static final Logger logger = LoggerFactory.getLogger(RedisPerformanceMonitor.class);
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    /**
     * Redis性能监控
     */
    public void monitorPerformance() {
        logger.info("开始Redis性能监控...");
        
        // 监控QPS
        monitorQPS();
        
        // 监控内存使用
        monitorMemoryUsage();
        
        // 监控连接数
        monitorConnections();
        
        // 监控响应时间
        monitorResponseTime();
    }
    
    /**
     * 监控QPS
     */
    private void monitorQPS() {
        logger.info("监控QPS...");
        
        // 获取Redis信息
        Properties info = redisTemplate.getConnectionFactory()
            .getConnection().info();
        
        // 解析QPS信息
        String totalCommandsProcessed = info.getProperty("total_commands_processed");
        String uptimeInSeconds = info.getProperty("uptime_in_seconds");
        
        if (totalCommandsProcessed != null && uptimeInSeconds != null) {
            long commands = Long.parseLong(totalCommandsProcessed);
            long uptime = Long.parseLong(uptimeInSeconds);
            
            double qps = commands / (double) uptime;
            
            logger.info("当前QPS：{:.2f}", qps);
            logger.info("总命令数：{}", commands);
            logger.info("运行时间：{} 秒", uptime);
        }
    }
    
    /**
     * 监控内存使用
     */
    private void monitorMemoryUsage() {
        logger.info("监控内存使用...");
        
        Properties info = redisTemplate.getConnectionFactory()
            .getConnection().info();
        
        String usedMemory = info.getProperty("used_memory_human");
        String maxMemory = info.getProperty("maxmemory_human");
        
        logger.info("已使用内存：{}", usedMemory);
        logger.info("最大内存：{}", maxMemory);
        
        // 计算内存使用率
        if (usedMemory != null && maxMemory != null) {
            double usedMB = parseMemorySize(usedMemory);
            double maxMB = parseMemorySize(maxMemory);
            
            if (maxMB > 0) {
                double usagePercent = (usedMB / maxMB) * 100;
                logger.info("内存使用率：{:.2f}%", usagePercent);
                
                if (usagePercent > 80) {
                    logger.warn("内存使用率过高，建议优化！");
                }
            }
        }
    }
    
    /**
     * 监控连接数
     */
    private void monitorConnections() {
        logger.info("监控连接数...");
        
        Properties info = redisTemplate.getConnectionFactory()
            .getConnection().info();
        
        String connectedClients = info.getProperty("connected_clients");
        String maxClients = info.getProperty("maxclients");
        
        logger.info("当前连接数：{}", connectedClients);
        logger.info("最大连接数：{}", maxClients);
        
        // 检查连接数是否过高
        if (connectedClients != null && maxClients != null) {
            int current = Integer.parseInt(connectedClients);
            int max = Integer.parseInt(maxClients);
            
            double usagePercent = (current / (double) max) * 100;
            logger.info("连接数使用率：{:.2f}%", usagePercent);
            
            if (usagePercent > 80) {
                logger.warn("连接数使用率过高，建议优化！");
            }
        }
    }
    
    /**
     * 监控响应时间
     */
    private void monitorResponseTime() {
        logger.info("监控响应时间...");
        
        int testCount = 1000;
        long totalTime = 0;
        
        for (int i = 0; i < testCount; i++) {
            String key = "test:response:" + i;
            String value = "test:value:" + i;
            
            long startTime = System.nanoTime();
            redisTemplate.opsForValue().set(key, value);
            redisTemplate.opsForValue().get(key);
            long endTime = System.nanoTime();
            
            totalTime += (endTime - startTime);
        }
        
        double avgResponseTime = totalTime / (testCount * 2.0) / 1_000_000.0; // 转换为毫秒
        
        logger.info("平均响应时间：{:.4f} 毫秒", avgResponseTime);
        
        if (avgResponseTime > 1.0) {
            logger.warn("响应时间过长，建议优化！");
        }
    }
    
    /**
     * 解析内存大小
     */
    private double parseMemorySize(String memoryStr) {
        if (memoryStr == null) return 0;
        
        if (memoryStr.endsWith("K")) {
            return Double.parseDouble(memoryStr.substring(0, memoryStr.length() - 1)) / 1024.0;
        } else if (memoryStr.endsWith("M")) {
            return Double.parseDouble(memoryStr.substring(0, memoryStr.length() - 1));
        } else if (memoryStr.endsWith("G")) {
            return Double.parseDouble(memoryStr.substring(0, memoryStr.length() - 1)) * 1024.0;
        }
        
        return Double.parseDouble(memoryStr) / (1024 * 1024); // 假设是字节
    }
}