清空redis缓存

一、背景：

做双十一的接口压测，每次压测接口前需要清空redis 对应的 key 的 缓存，但是用的链接redis终端，每次清缓存，都要在终端的key的每个value手动点一次删除，很麻烦，而且，点得稍微频繁一点，终端就会卡死，很影响效率，压测联调有很多的时间都浪费在这个终端。

 

二、方案

只能写一个工具，批量获取redis的key：value值，并清空缓存value

代码：

# !/usr/bin/python
# -*- coding:utf-8 -*-
# Time    : 2020-10-31 10:02
# author  : Zhoujunjun
# File    : py_redis

import redis
from rediscluster import StrictRedisCluster
import threading
from time import ctime
import time,sys,os

# 链接单个机器的redis
# r = redis.StrictRedis(host='redis5-test.swj.com',port=7619,db=0)
# 写入key:value
# r.set.set('test','zjntest')
# 测试是否可以根据key，查询出value，证明链接成功
# print(redis_conn.keys('test'))
# 删除key的vlue
# r.delete("test")
# r.keys("Swj:ActivityCenter:*");
# print(r.keys("Swj:ActivityCenter:*"))


# 链接机器集群的redis
class RedisCluster(object):  # 连接redis集群
    def __init__(self,conn_list):
        self.conn_list = conn_list  # 连接列表

    def connect(self):
        """
        连接redis集群
        :return: object
        """
        try:
            # 非密码连接redis集群
            # 跳过检查的参数 skip_full_coverage_check=True
            redisconn = StrictRedisCluster(startup_nodes=self.conn_list,skip_full_coverage_check=True)
            # 使用密码连接redis集群
            # redisconn = StrictRedisCluster(startup_nodes=self.conn_list, password='123456')
            return redisconn
        except Exception as e:
            print(e)
            print("错误,连接redis 集群失败")
            return False

    def get_state(self):
        """
        获取状态
        :return:
        """
        res = RedisCluster(self.conn_list).connect()
        # print("连接集群对象",res,type(res),res.__dict__)
        if not res:
            return False

        dic = res.cluster_info()  # 查看info信息, 返回dict

        for i in dic:  # 遍历dict
            ip = i.split(":")[0]
            if dic[i].get('cluster_state'):  # 获取状态
                print("节点状态, ip: ", ip, "value: ", dic[i].get('cluster_state'))

redis_basis_conn = [{'host': 'redis1-test.swj.com', 'port': 7615},
                    {'host': 'redis2-test.swj.com', 'port': 7616},
                    {'host': 'redis3-test.swj.com', 'port': 7617},
                    {'host': 'redis4-test.swj.com', 'port': 7618},
                    {'host': 'redis5-test.swj.com', 'port': 7619},
                    {'host': 'redis6-test.swj.com', 'port': 7620}]

redis_conn = RedisCluster(redis_basis_conn).connect()

"""测试 redis写入、获取、删除 是否成功"""
# redis_conn.set('test','zjntest')
# print(redis_conn.keys('test'))
# redis_conn.delete('test')
# print(redis_conn.keys('test'))

"""删除全部缓存"""
# 获取 redis 双十一抢奖品的缓存
# swj = redis_conn.keys('Swj:ActivityCenter:*')
# 删除 redis 缓存
# print('start at:', ctime())
# for i in swj:
#     redis_conn.delete(i)
# print('end at:', ctime())
# swj = redis_conn.keys('Swj:ActivityCenter:*')
# print(len(swj))

"""只删除抢券活动的缓存"""
# 执行数据库脚本之前清
# swj = redis_conn.keys('Swj:ActivityCenter:HasWinPrize:*')
swj = redis_conn.keys('Swj:ActivityCenter:PrizeQueue-15')
# 执行数据库脚本之后清
# swj = redis_conn.keys('Swj:ActivityCenter:AllSeason')
# swj = redis_conn.keys('Swj:ActivityCenter:ActivitySeason-15')
# print(len(swj))
print(len(swj))
# 由于删除速度比较慢，1s才删除100多个，3w个值，需要删除2-3分钟，所以开多个线程删除
# 把redis缓存列表分成6段，开6个线程分布清除
l = len(swj)//6
def swj_del_t1():
    print('child thread 1, start at:', ctime())
    k = 0
    for i in swj[0:l+1]:
		k += 1
        redis_conn.delete(i)
    print('delete_num:' + str(k))
    print('child thread 1, end at:', ctime())


def swj_del_t2():
    print('child thread 2, start at:', ctime())
    k = 0
    for i in swj[l:2*l+1]:
        k += 1
        redis_conn.delete(i)
    print('delete_num:'+ str(k))
    print('child thread 2, end at:', ctime())

def swj_del_t3():
    print('child thread 3, start at:', ctime())
    k = 0
    for i in swj[2*l:3*l+1]:
        k += 1
        redis_conn.delete(i)
    print('delete_num:'+ str(k))
    print('child thread 3, end at:', ctime())

def swj_del_t4():
    print('child thread 4, start at:', ctime())
    k = 0
    for i in swj[3*l:4*l+1]:
		k += 1
        redis_conn.delete(i)
    print('delete_num:' + str(k))
    print('child thread 4, end at:', ctime())

def swj_del_t5():
    print('child thread 5, start at:', ctime())
    k = 0
    for i in swj[4*l:5*l+1]:
        k += 1
        redis_conn.delete(i)
    print('delete_num:'+ str(k))
    print('child thread 5, end at:', ctime())

def swj_del_t6():
    print('child thread 6, start at:', ctime())
    k = 0
    for i in swj[5*l:]:
        k += 1
        redis_conn.delete(i)
    print('delete_num:'+ str(k))
    print('child thread 6, end at:', ctime())
t1 = threading.Thread(target=swj_del_t1)
t2 = threading.Thread(target=swj_del_t2)
t3 = threading.Thread(target=swj_del_t3)
t4 = threading.Thread(target=swj_del_t4)
t5 = threading.Thread(target=swj_del_t5)
t6 = threading.Thread(target=swj_del_t6)
t1.start()
t2.start()
t3.start()
t4.start()
t5.start()
t6.start()
t1.join()
t2.join()
t3.join()
t4.join()
t5.join()
t6.join()
swj = redis_conn.keys('Swj:ActivityCenter:*')
print(len(swj))

三、使用方法：

1、在python环境里面安装rediscluster库，

2、将需要清除缓存的key对应的name（列表里面的值）值作为 redis_conn.keys 的传参

3、执行代码文件