超大集合key获取value速度慢的解决方式

柔光的暖阳◎ 2022-10-26 01:23 220阅读 0赞

集合key获取速度慢的解决方式  
 1，使用pop命令每次获取并删除固定数量  
 2，使用有序集合每次获取固定排序范围的集合（有顺序要求的key）  
 3，Key+hash(分桶的处理)，分散到多个key存储

方式一对应的代码：

public void dealRedis(String posMenuVersion, String sequenceNo) \{

long setSize = sSetSize(ProductKeyUtils.keySet(posMenuVersion, sequenceNo));  
        if (setSize > 0) \{  
            while (setSize > 0) \{  
                long start = System.currentTimeMillis();  
                log.info("将要删除key数量\{\}", setSize);  
                List<Object> listkeys = sPop(ProductKeyUtils.keySet(posMenuVersion, sequenceNo), 5000);

long end = System.currentTimeMillis();  
                log.info("获取部分valeu获取时间：\{\}", end - start);  
                Set<Object> sets = new HashSet<>(listkeys);  
                deleteSetWithKeys(sets);  
                long sizeTime = System.currentTimeMillis();  
                setSize = sSetSize(ProductKeyUtils.keySet(posMenuVersion, sequenceNo));  
                log.info("size获取时间：\{\}", System.currentTimeMillis() - sizeTime);  
            \}  
        \} else \{  
            deleteByKey("SPLIT\_MENU." + posMenuVersion + "." + sequenceNo + ".\*");  
            deleteByKey("SPLIT\_DAYTYPE\_DAYPART." + posMenuVersion + "." + sequenceNo + ".\*");  
            deleteByKey("SPLIT\_STORE\_MENUKEY." + posMenuVersion + "." + sequenceNo + ".\*");  
            deleteByKey("SPLIT\_STORE\_PRODUCTKEY." + posMenuVersion + "." + sequenceNo + ".\*");  
            deleteByKey("SPLIT\_CATERGORY\_PRODUCT." + posMenuVersion + "." + sequenceNo + ".\*");  
            deleteByKey("SPLIT\_PRODUCT\_DEATIL." + posMenuVersion + "." + sequenceNo + ".\*");  
            deleteByKey("SPLIT\_PRODUCT\_CATEGORY\_HASH\_" + posMenuVersion + "\_" + sequenceNo + "\*");  
            deleteByKey("SPLIT\_PRODUCT\_DEATIL\_HASH\_" + posMenuVersion + "\_" + sequenceNo + "\*");  
            deleteByKey("SPLIT\_DIMESSION\_STATUS\_NUM." + posMenuVersion + "." + sequenceNo + ".\*");  
            deleteByKey("SPLIT\_DIMESSION\_STATUS." + posMenuVersion + "." + sequenceNo + ".\*");  
        \}  
        Set<String> menuList = new HashSet<>();  
        //用storeInfo拼接  
        //获取商店使用的价格组信息  
        Map<String, Object> storePrices = getHashMap("STORE\_INFO");  
        if (null != storePrices && storePrices.size() > 0) \{  
            Set<String> storeCodes = storePrices.keySet();  
            if (null != storeCodes && storeCodes.size() > 0) \{  
                storeCodes.stream().forEach(storeCode -> \{  
                    menuList.add("MENU\_ONLINE\_VERSION\_DRAFT\_SPLIT." + storeCode);  
                \});  
            \}  
        \}

log.info("删除参考餐厅数：\{\}", menuList.size());  
        if (null != menuList && menuList.size() > 0) \{  
            Iterator menuIterator = menuList.iterator();  
            while (menuIterator.hasNext()) \{  
                String menu = menuIterator.next() + "";  
                Map<String, Object> secondmap = getMenuParamMap(menu);  
                for (Map.Entry<String, Object> entry : secondmap.entrySet()) \{  
                    String hashKey = entry.getKey() + "";  
                    String value = entry.getValue() + "";  
                    if (hashKey.contains(posMenuVersion + ".")) \{  
                        JSONObject map = JSON.parseObject(value);  
                        if (sequenceNo.equals(map.get("sequenceNo"))) \{  
                            redisHashDeleteKey(menu, hashKey);  
                        \}  
                    \}

\}  
            \}  
        \}

@Override  
    public List<Object> sPop(String key, long len) \{  
        try \{  
            SetOperations<String, Object> set = redisService.getRedisTemplate().opsForSet();  
            return set.pop(key, len);  
        \} finally \{  
            RedisConnectionUtils.unbindConnection(redisService.getRedisTemplate().getConnectionFactory());  
        \}  
    \}

@Override  
    public Long sSetSize(String key) \{  
        try \{  
            SetOperations<String, Object> set = redisService.getRedisTemplate().opsForSet();  
            return set.size(key);  
        \} finally \{  
            RedisConnectionUtils.unbindConnection(redisService.getRedisTemplate().getConnectionFactory());  
        \}  
    \}

@Override  
    public void deleteSetMatchKey(String setKey) \{  
        // 根据参数读取出所有的key  
        Set<Object> keys = sGet(setKey);  
        // 参数所有的key  
        deleteSetWithKeys(keys);  
    \}

@Override  
    public void deleteSetWithKeys(Set<Object> keys) \{  
        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：\{\}个 \{\}", deleteCount, partKeys);  
                    \}  
                \}  
            \}  
        \}  
    \}

@Override  
    public void deleteByKey(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);  
        \}  
    \}

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();  
    \}

private Set<String> scanKeys(String keyPrefix) \{  
        return scanKeys(keyPrefix, Integer.MAX\_VALUE);  
    \}

方式三参考：

[https://blog.csdn.net/beyond59241/article/details/78889867][https_blog.csdn.net_beyond59241_article_details_78889867]

[https_blog.csdn.net_beyond59241_article_details_78889867]: https://blog.csdn.net/beyond59241/article/details/78889867