用scan代替keys防止key过多，长时间阻塞，收集好所有的key会快于scan

旧城等待， 2022-12-30 12:55 177阅读 0赞

用scan代替keys防止key过多，长时间阻塞  
    scan的count是获取的数量  
      
      /\*\*  
     \* key模糊查询  
     \*  
     \* @param pattern key的前缀  
     \*/  
    @Override  
    public Set keys(String pattern) \{  
        // 根据前缀通配keys 用scan代替 redisService.getRedisTemplate().keys(pattern + "\*")  
        return scanKeys(pattern);  
    \}  
      
    /\*\*  
     \* 模糊匹配删除key  
     \*  
     \* @param prex  
     \* @return  
     \* @throws  
     \* @author yuhui  
     \* @date 2020/10/9 13:39  
     \*/  
    @Override  
    public void deleteByPrex(String prex) \{

// scan 分页查询key并进行删除  
        Set<String> keys = scanKeys(prex, BATCH\_COUNT);  
        try \{  
            while (keys != null && keys.size() > 0) \{  
                // 批量删除key  
                long deleteCount = redisService.getRedisTemplate().delete(keys);  
                log.info("分页删除Reids中keys:\{\}(\{\}), \{\}个", prex, keys.size(), deleteCount);

// 删除的数量等于分页最大数量时，需要再次查询是否有剩余的key  
                if (keys.size() < BATCH\_COUNT) \{  
                    // key数量小于批量的最大数量时，说明都处理完了  
                    keys.clear();  
                \} else \{  
                    keys = scanKeys(prex, BATCH\_COUNT);  
                \}  
            \}  
        \} catch (Exception e) \{  
            log.warn("分页删除Reids异常 keys:" + prex, e);  
        \}  
    \}

/\*\*  
     \* 获取指定前缀的一系列key  
     \* 使用scan命令代替keys, Redis是单线程处理，keys命令在KEY数量较多时，  
     \* 操作效率极低【时间复杂度为O(N)】，该命令一旦执行会严重阻塞线上其它命令的正常请求  
     \*  
     \* @param keyPrefix 带通配符的key  
     \* @param pageSize  批量数量  
     \* @return 查询出来的key  
     \*/  
    private Set<String> scanKeys(String keyPrefix, long pageSize) \{  
        try \{  
            Set<String> binaryKeys = new HashSet<>();  
            ScanOptions options = ScanOptions.scanOptions().match(keyPrefix).count(pageSize).build();  
            Cursor<String> cursor = (Cursor<String>) redisService.getRedisTemplate().executeWithStickyConnection(  
                    redisConnection -> new ConvertingCursor<>(redisConnection.scan(options),  
                            redisService.getRedisTemplate().getKeySerializer()::deserialize));  
            while (cursor.hasNext()) \{  
                binaryKeys.add(cursor.next());  
            \}  
            log.info("分页scan keys:\{\}, \{\}个", keyPrefix, binaryKeys.size());  
            return binaryKeys;  
//            \});  
        \} catch (Exception e) \{  
            log.error("获取redis keys异常", e);  
        \}

return Collections.emptySet();  
    \}

用scan在redis缓存数量大的时候会删除慢：

可以先收集好所有的key，然后分页删除

pcmRedisService.sSet(ProductKeyUtils.keySet(demissionCategory.getPosMenuVersion(), demissionCategory.getSequenceNo()),dimessionKey);

public void deleteByPrexNew(String prex) {
    
        // 根据参数读取出所有的key
        Set<Object> keys = sGet(prex);
        log.info("待删除key", keys);
        if (keys != null && !keys.isEmpty()) {
            // 因为有时key很多，所以要分批处理
            long limit = (keys.size() + BATCH_COUNT - 1) / BATCH_COUNT;
            // 将key分批
            List<Set<Object>> splitKeys = Stream.iterate(0, n -> n + 1).limit(limit).parallel()
                    .map(a -> keys.stream().skip(a * BATCH_COUNT).limit(BATCH_COUNT).parallel()
                            .collect(Collectors.toSet())).collect(Collectors.toList());
            if (!splitKeys.isEmpty()) {
                for (Set<Object> partKeys : splitKeys) {
                    if (partKeys != null && !partKeys.isEmpty()) {
                        // 批量删除key
                        long deleteCount = redisService.getRedisTemplate().delete(partKeys);
                        log.info("删除Reids中keys：{}, {}个", prex, deleteCount);
                        if (deleteCount != partKeys.size()) {
                            log.warn("预期删除{}个，实际删除{}个", partKeys.size(), deleteCount);
                        }
                    }
                }
            }
        }
    }