1
主节点故障检测流程：
2
1. 从节点检测主节点超时（cluster-node-timeout）
3
2. 从节点标记主节点为PFAIL状态
4
3. 通过Gossip协议传播故障信息
5
4. 当大多数节点确认故障时，标记为FAIL
6
5. 从节点发起选举，成为新主节点

1
// Redis源码中的slot计算
2
unsigned int keyHashSlot(char *key, int keylen) {
3
    int s, e;
4
    for (s = 0; s < keylen; s++)
5
        if (key[s] == '{') break;
6
    if (s == keylen) return crc16(key,keylen) & 0x3FFF;
7
    for (e = s+1; e < keylen; e++)
8
        if (key[e] == '}') break;
9
    if (e == keylen || e == s+1) return crc16(key,keylen) & 0x3FFF;
10
    return crc16(key+s+1,e-s-1) & 0x3FFF;
11
}

1
总slot数：16384
2
节点数：n
3
每个节点slot数 ≈ 16384 / n
4

5
例如：6个节点的分配
6
Node1: 0-2729     (2730个slot)
7
Node2: 2730-5459  (2730个slot)
8
Node3: 5460-8191  (2732个slot)
9
Node4: 8192-10921 (2730个slot)
10
Node5: 10922-13651(2730个slot)
11
Node6: 13652-16383(2732个slot)

1
1. 节点发现：各节点通过MEET命令建立连接
2
2. Slot分配：16384个slot均匀分配给主节点
3
3. 主从关系建立：从节点复制指定主节点
4
4. 集群状态同步：通过Gossip协议同步拓扑信息

1
应用层：Gossip协议消息
2
传输层：TCP连接
3
网络层：IP路由
4
数据链路层：以太网帧

1
cluster_state:ok                    # 集群状态
2
cluster_slots_assigned:16384       # 已分配slot数
3
cluster_slots_ok:16384             # 正常slot数
4
cluster_slots_pfail:0              # 疑似故障slot数
5
cluster_slots_fail:0               # 故障slot数
6
cluster_known_nodes:6              # 已知节点数
7
cluster_size:3                     # 集群大小（主节点数）

1
1. 源节点准备迁移：标记slot为MIGRATING状态
2
2. 目标节点准备接收：标记slot为IMPORTING状态
3
3. 获取slot中的所有key：CLUSTER GETKEYSINSLOT
4
4. 逐个迁移key：MIGRATE命令
5
5. 更新slot归属：CLUSTER SETSLOT
6
6. 广播slot变更：Gossip协议同步

1
全量同步过程：
2
1. 从节点发送PSYNC命令
3
2. 主节点判断是否首次同步
4
3. 主节点执行BGSAVE生成RDB
5
4. 主节点发送RDB给从节点
6
5. 从节点载入RDB数据
7
6. 主节点发送复制积压缓冲区数据
8

9
增量同步过程：
10
1. 主节点记录写命令到复制积压缓冲区
11
2. 主节点异步发送命令到从节点
12
3. 从节点执行收到的命令

1
// 节点标记为PFAIL的条件
2
if (now - node->ping_sent > server.cluster_node_timeout/2 &&
3
    now - node->pong_received > server.cluster_node_timeout) {
4
    node->flags |= CLUSTER_NODE_PFAIL;
5
}

1
1. 节点收到其他节点的PFAIL报告
2
2. 统计报告PFAIL的节点数量
3
3. 如果超过集群节点数量的一半，标记为FAIL
4
4. 广播FAIL状态到整个集群

1
1. 从节点检测主节点FAIL
2
2. 从节点延迟选举（避免同时选举）
3
3. 从节点广播选举请求
4
4. 主节点投票给从节点
5
5. 获得大多数票的从节点成为新主节点
6
6. 新主节点广播成为主节点的消息

1
DELAY = 500ms + random(0~500ms) + SLAVE_RANK * 1000ms

1
#!/bin/bash
2
# Redis集群监控脚本
3

4
NODES="192.168.1.100:7000 192.168.1.100:7001 192.168.1.100:7002"
5

6
for node in $NODES; do
7
    echo "=== $node ==="
8
    redis-cli -h ${node%:*} -p ${node#*:} INFO memory | grep used_memory_human
9
    redis-cli -h ${node%:*} -p ${node#*:} INFO stats | grep instantaneous_ops_per_sec
10
    redis-cli -h ${node%:*} -p ${node#*:} CLUSTER INFO | grep cluster_state
11
done

1
CPU配置建议：
2
- 每个Redis实例绑定特定CPU核心
3
- 避免CPU频繁切换和缓存失效
4

5
内存配置建议：
6
- 预留足够的系统内存（避免OOM）
7
- 考虑fork操作的内存需求
8
- 合理设置maxmemory
9

10
磁盘配置建议：
11
- 使用SSD存储AOF和RDB文件
12
- 分离不同节点的存储路径
13
- 定期清理日志文件

1
import redis.clients.jedis.JedisCluster;
2
import redis.clients.jedis.HostAndPort;
3

4
public class RedisClusterExample {
5
    public static void main(String[] args) {
6
        // 集群节点配置
7
        Set<HostAndPort> jedisClusterNodes = new HashSet<>();
8
        jedisClusterNodes.add(new HostAndPort("192.168.1.100", 7000));
9
        jedisClusterNodes.add(new HostAndPort("192.168.1.100", 7001));
10
        jedisClusterNodes.add(new HostAndPort("192.168.1.100", 7002));
11

12
        // 连接配置
13
        JedisPoolConfig poolConfig = new JedisPoolConfig();
14
        poolConfig.setMaxTotal(20);
15
        poolConfig.setMaxIdle(10);
16
        poolConfig.setMinIdle(5);
17

18
        // 创建集群连接
19
        JedisCluster jedisCluster = new JedisCluster(
20
            jedisClusterNodes,
21
            2000, 2000, 3,
22
            poolConfig
23
        );
24

25
        // 使用Hash Tag确保相关数据在同一slot
26
        jedisCluster.set("user:{123}:profile", "张三");
27
        jedisCluster.set("user:{123}:score", "95");
28

29
        // 批量操作（需要在同一slot）
30
        jedisCluster.mset(
31
            "order:{456}:info", "订单信息",
32
            "order:{456}:status", "已支付"
33
        );
34

35
        jedisCluster.close();
36
    }
37
}

1
from rediscluster import RedisCluster
2
import time
3

4
# 集群节点配置
5
startup_nodes = [
6
    {"host": "192.168.1.100", "port": "7000"},
7
    {"host": "192.168.1.100", "port": "7001"},
8
    {"host": "192.168.1.100", "port": "7002"},
9
]
10

11
# 创建集群连接
12
rc = RedisCluster(
13
    startup_nodes=startup_nodes,
14
    decode_responses=True,
15
    skip_full_coverage_check=True,
16
    health_check_interval=30
17
)
18

19
# 分布式计数器示例
20
def distributed_counter(key, increment=1):
21
    with rc.pipeline() as pipe:
22
        while True:
23
            try:
24
                pipe.watch(key)
25
                current_value = pipe.get(key) or 0
26
                pipe.multi()
27
                pipe.set(key, int(current_value) + increment)
28
                pipe.execute()
29
                break
30
            except:
31
                continue
32
    return int(current_value) + increment
33

34
# 使用示例
35
counter_value = distributed_counter("global:counter")
36
print(f"当前计数值: {counter_value}")

1
import uuid
2
import time
3
from rediscluster import RedisCluster
4

5
class RedisDistributedLock:
6
    def __init__(self, redis_client, key, timeout=10):
7
        self.redis = redis_client
8
        self.key = key
9
        self.timeout = timeout
10
        self.identifier = str(uuid.uuid4())
11

12
    def acquire(self):
13
        """获取锁"""
14
        end = time.time() + self.timeout
15
        while time.time() < end:
16
            # 使用SET命令的NX和EX参数实现原子操作
17
            if self.redis.set(self.key, self.identifier, nx=True, ex=self.timeout):
18
                return True
19
            time.sleep(0.001)
20
        return False
21

22
    def release(self):
23
        """释放锁"""
24
        # 使用Lua脚本保证原子性
25
        script = """
26
        if redis.call("GET", KEYS[1]) == ARGV[1] then
27
            return redis.call("DEL", KEYS[1])
28
        else
29
            return 0
30
        end
31
        """
32
        return self.redis.eval(script, 1, self.key, self.identifier)
33

34
# 使用示例
35
def critical_section():
36
    lock = RedisDistributedLock(rc, "resource:lock", timeout=30)
37
    if lock.acquire():
38
        try:
39
            print("获取锁成功，执行关键代码")
40
            # 执行需要互斥的代码
41
            time.sleep(5)
42
        finally:
43
            lock.release()
44
            print("释放锁成功")
45
    else:
46
        print("获取锁失败")

1
import time
2
import random
3
from rediscluster import RedisCluster
4

5
class Redlock:
6
    def __init__(self, redis_instances):
7
        self.redis_instances = redis_instances
8
        self.quorum = len(redis_instances) // 2 + 1
9

10
    def acquire_lock(self, key, ttl, identifier):
11
        """获取红锁"""
12
        start_time = time.time()
13
        acquired = 0
14

15
        for redis_instance in self.redis_instances:
16
            try:
17
                if redis_instance.set(key, identifier, nx=True, px=ttl):
18
                    acquired += 1
19
            except:
20
                pass
21

22
        # 计算获取锁的时间
23
        elapsed_time = (time.time() - start_time) * 1000
24

25
        # 检查是否获得了大多数锁，且剩余时间充足
26
        if acquired >= self.quorum and elapsed_time < ttl:
27
            return True
28
        else:
29
            # 释放已获得的锁
30
            self.release_lock(key, identifier)
31
            return False
32

33
    def release_lock(self, key, identifier):
34
        """释放红锁"""
35
        script = """
36
        if redis.call("GET", KEYS[1]) == ARGV[1] then
37
            return redis.call("DEL", KEYS[1])
38
        else
39
            return 0
40
        end
41
        """
42

43
        for redis_instance in self.redis_instances:
44
            try:
45
                redis_instance.eval(script, 1, key, identifier)
46
            except:
47
                pass

1
def update_user_cache(user_id, user_data):
2
    """更新用户缓存，保证最终一致性"""
3

4
    # 1. 先删除缓存
5
    cache_key = f"user:{user_id}"
6
    rc.delete(cache_key)
7

8
    # 2. 更新数据库
9
    update_user_in_database(user_id, user_data)
10

11
    # 3. 异步更新缓存
12
    import threading
13
    def async_update_cache():
14
        time.sleep(0.1)  # 短暂延迟
15
        fresh_data = get_user_from_database(user_id)
16
        rc.setex(cache_key, 3600, json.dumps(fresh_data))
17

18
    threading.Thread(target=async_update_cache).start()
19

20
def get_user_with_consistency(user_id):
21
    """获取用户数据，保证一致性"""
22
    cache_key = f"user:{user_id}"
23

24
    # 1. 尝试从缓存获取
25
    cached_data = rc.get(cache_key)
26
    if cached_data:
27
        return json.loads(cached_data)
28

29
    # 2. 缓存未命中，从数据库获取
30
    user_data = get_user_from_database(user_id)
31
    if user_data:
32
        # 设置缓存，并添加随机过期时间防止缓存雪崩
33
        expire_time = 3600 + random.randint(0, 600)
34
        rc.setex(cache_key, expire_time, json.dumps(user_data))
35

36
    return user_data

1
def transfer_points(from_user_id, to_user_id, points):
2
    """积分转账，保证事务一致性"""
3

4
    # 使用Hash Tag确保相关数据在同一slot
5
    from_key = f"points:{{transfer}}:{from_user_id}"
6
    to_key = f"points:{{transfer}}:{to_user_id}"
7
    lock_key = f"lock:{{transfer}}:transfer"
8

9
    # 获取分布式锁
10
    lock = RedisDistributedLock(rc, lock_key, timeout=30)
11
    if not lock.acquire():
12
        raise Exception("获取锁失败，转账被取消")
13

14
    try:
15
        # 使用管道保证原子性
16
        with rc.pipeline() as pipe:
17
            # 监听相关键
18
            pipe.watch(from_key, to_key)
19

20
            # 获取当前余额
21
            from_balance = int(pipe.get(from_key) or 0)
22
            to_balance = int(pipe.get(to_key) or 0)
23

24
            # 检查余额是否充足
25
            if from_balance < points:
26
                raise Exception("余额不足")
27

28
            # 开始事务
29
            pipe.multi()
30
            pipe.set(from_key, from_balance - points)
31
            pipe.set(to_key, to_balance + points)
32

33
            # 记录转账日志
34
            log_key = f"transfer_log:{{transfer}}:{int(time.time())}"
35
            pipe.hset(log_key, mapping={
36
                'from_user': from_user_id,
37
                'to_user': to_user_id,
38
                'points': points,
39
                'timestamp': int(time.time())
40
            })
41

42
            # 执行事务
43
            pipe.execute()
44

45
    except Exception as e:
46
        print(f"转账失败: {e}")
47
        raise
48
    finally:
49
        lock.release()
50

51
# 使用示例
52
try:
53
    transfer_points("user1", "user2", 100)
54
    print("转账成功")
55
except Exception as e:
56
    print(f"转账失败: {e}")

1
#!/bin/bash
2
# 节点健康检查脚本
3

4
check_node_health() {
5
    local host=$1
6
    local port=$2
7

8
    # 检查节点是否响应
9
    if redis-cli -h $host -p $port ping 2>/dev/null | grep -q "PONG"; then
10
        echo "[$host:$port] 节点正常"
11
        return 0
12
    else
13
        echo "[$host:$port] 节点异常，尝试重启"
14

15
        # 尝试重启节点
16
        systemctl restart redis-server@$port
17
        sleep 5
18

19
        # 再次检查
20
        if redis-cli -h $host -p $port ping 2>/dev/null | grep -q "PONG"; then
21
            echo "[$host:$port] 节点重启成功"
22

23
            # 检查是否需要重新加入集群
24
            cluster_state=$(redis-cli -h $host -p $port CLUSTER INFO | grep cluster_state)
25
            if [[ $cluster_state == *"fail"* ]]; then
26
                echo "[$host:$port] 需要手动修复集群状态"
27
                # 这里可以添加自动修复逻辑
28
            fi
29
        else
30
            echo "[$host:$port] 节点重启失败，需要人工介入"
31
            # 发送告警通知
32
            send_alert "Redis节点 $host:$port 重启失败"
33
        fi
34
        return 1
35
    fi
36
}
37

38
# 检查所有节点
39
nodes=("192.168.1.100:7000" "192.168.1.100:7001" "192.168.1.100:7002"
40
       "192.168.1.100:7003" "192.168.1.100:7004" "192.168.1.100:7005")
41

42
for node in "${nodes[@]}"; do
43
    IFS=':' read -ra ADDR <<< "$node"
44
    check_node_health "${ADDR[0]}" "${ADDR[1]}"
45
done

1
def check_data_consistency():
2
    """检查集群数据一致性"""
3

4
    # 获取所有主节点
5
    cluster_nodes = rc.cluster_nodes()
6
    master_nodes = []
7

8
    for node_id, node_info in cluster_nodes.items():
9
        if 'master' in node_info['flags']:
10
            master_nodes.append({
11
                'id': node_id,
12
                'host': node_info['host'],
13
                'port': node_info['port'],
14
                'slots': node_info['slots']
15
            })
16

17
    inconsistent_keys = []
18

19
    # 检查每个key在主从之间是否一致
20
    for master in master_nodes:
21
        master_client = redis.Redis(host=master['host'], port=master['port'])
22

23
        # 获取该主节点的所有从节点
24
        slaves = get_slave_nodes(master['id'])
25

26
        # 扫描主节点的所有key
27
        for key in master_client.scan_iter(count=100):
28
            master_value = master_client.get(key)
29

30
            # 检查每个从节点的对应key
31
            for slave in slaves:
32
                slave_client = redis.Redis(host=slave['host'], port=slave['port'])
33
                slave_value = slave_client.get(key)
34

35
                if master_value != slave_value:
36
                    inconsistent_keys.append({
37
                        'key': key,
38
                        'master_value': master_value,
39
                        'slave_value': slave_value,
40
                        'master_node': f"{master['host']}:{master['port']}",
41
                        'slave_node': f"{slave['host']}:{slave['port']}"
42
                    })
43

44
    return inconsistent_keys
45

46
def repair_inconsistent_data(inconsistent_keys):
47
    """修复不一致数据"""
48
    for item in inconsistent_keys:
49
        print(f"修复key: {item['key']}")
50

51
        # 从主节点重新同步到从节点
52
        master_host, master_port = item['master_node'].split(':')
53
        slave_host, slave_port = item['slave_node'].split(':')
54

55
        # 触发部分重同步
56
        slave_client = redis.Redis(host=slave_host, port=slave_port)
57
        slave_client.execute_command('REPLICAOF', master_host, master_port)

1
#!/bin/bash
2
# 脑裂检测脚本
3

4
detect_split_brain() {
5
    declare -A masters
6
    node_count=0
7

8
    # 检查每个节点认为的主节点情况
9
    for node in "${nodes[@]}"; do
10
        IFS=':' read -ra ADDR <<< "$node"
11
        host=${ADDR[0]}
12
        port=${ADDR[1]}
13

14
        # 获取节点信息
15
        cluster_info=$(redis-cli -h $host -p $port CLUSTER NODES 2>/dev/null)
16
        if [ $? -eq 0 ]; then
17
            node_count=$((node_count + 1))
18

19
            # 统计主节点数量
20
            master_count=$(echo "$cluster_info" | grep "master" | wc -l)
21
            masters[$node]=$master_count
22

23
            echo "节点 $node 看到的主节点数: $master_count"
24
        else
25
            echo "节点 $node 无法连接"
26
        fi
27
    done
28

29
    # 检查是否存在脑裂
30
    expected_masters=3  # 期望的主节点数
31
    split_brain=false
32

33
    for node in "${!masters[@]}"; do
34
        if [ "${masters[$node]}" -ne $expected_masters ]; then
35
            echo "警告：节点 $node 的主节点数量异常: ${masters[$node]}"
36
            split_brain=true
37
        fi
38
    done
39

40
    if [ "$split_brain" = true ]; then
41
        echo "检测到脑裂现象，需要人工介入修复"
42
        # 这里可以添加自动修复逻辑或发送告警
43
        return 1
44
    else
45
        echo "集群状态正常，未检测到脑裂"
46
        return 0
47
    fi
48
}
49

50
# 执行脑裂检测
51
detect_split_brain

1
#!/bin/bash
2
# 集群网络诊断脚本
3

4
diagnose_cluster_network() {
5
    local nodes=("$@")
6

7
    echo "=== 集群网络诊断 ==="
8

9
    for i in "${!nodes[@]}"; do
10
        for j in "${!nodes[@]}"; do
11
            if [ $i -ne $j ]; then
12
                IFS=':' read -ra FROM <<< "${nodes[$i]}"
13
                IFS=':' read -ra TO <<< "${nodes[$j]}"
14

15
                from_host=${FROM[0]}
16
                from_port=${FROM[1]}
17
                to_host=${TO[0]}
18
                to_port=${TO[1]}
19

20
                echo "检查 $from_host:$from_port -> $to_host:$to_port"
21

22
                # 1. 检查服务端口连通性
23
                if timeout 3 bash -c "</dev/tcp/$to_host/$to_port"; then
24
                    echo "  ✓ 服务端口 $to_port 连通"
25
                else
26
                    echo "  ✗ 服务端口 $to_port 不通"
27
                fi
28

29
                # 2. 检查集群总线端口连通性
30
                bus_port=$((to_port + 10000))
31
                if timeout 3 bash -c "</dev/tcp/$to_host/$bus_port"; then
32
                    echo "  ✓ 集群总线端口 $bus_port 连通"
33
                else
34
                    echo "  ✗ 集群总线端口 $bus_port 不通"
35
                fi
36

37
                # 3. 检查网络延迟
38
                ping_result=$(ping -c 3 -W 1000 $to_host 2>/dev/null | grep "avg")
39
                if [ $? -eq 0 ]; then
40
                    echo "  ✓ 网络延迟: $ping_result"
41
                else
42
                    echo "  ✗ 网络不可达"
43
                fi
44

45
                echo ""
46
            fi
47
        done
48
    done
49
}
50

51
# 执行网络诊断
52
nodes=("192.168.1.100:7000" "192.168.1.100:7001" "192.168.1.100:7002")
53
diagnose_cluster_network "${nodes[@]}"

1
def analyze_slow_queries():
2
    """分析集群慢查询"""
3

4
    cluster_nodes = rc.cluster_nodes()
5
    all_slow_queries = []
6

7
    for node_id, node_info in cluster_nodes.items():
8
        if 'master' in node_info['flags']:
9
            host = node_info['host']
10
            port = node_info['port']
11

12
            # 连接到具体节点
13
            node_client = redis.Redis(host=host, port=port)
14

15
            # 获取慢查询日志
16
            slow_queries = node_client.slowlog_get(100)
17

18
            for query in slow_queries:
19
                all_slow_queries.append({
20
                    'node': f"{host}:{port}",
21
                    'id': query['id'],
22
                    'start_time': query['start_time'],
23
                    'duration': query['duration'],
24
                    'command': ' '.join(str(arg) for arg in query['command'])
25
                })
26

27
    # 按执行时间排序
28
    all_slow_queries.sort(key=lambda x: x['duration'], reverse=True)
29

30
    # 分析结果
31
    print("=== 慢查询分析报告 ===")
32
    for i, query in enumerate(all_slow_queries[:10]):
33
        print(f"{i+1}. 节点: {query['node']}")
34
        print(f"   执行时间: {query['duration']} μs")
35
        print(f"   命令: {query['command'][:100]}...")
36
        print()
37

38
    return all_slow_queries
39

40
def optimize_slow_queries(slow_queries):
41
    """慢查询优化建议"""
42
    command_stats = {}
43

44
    for query in slow_queries:
45
        cmd = query['command'].split()[0].upper()
46
        if cmd not in command_stats:
47
            command_stats[cmd] = {'count': 0, 'total_time': 0}
48

49
        command_stats[cmd]['count'] += 1
50
        command_stats[cmd]['total_time'] += query['duration']
51

52
    print("=== 优化建议 ===")
53
    for cmd, stats in sorted(command_stats.items(),
54
                           key=lambda x: x[1]['total_time'], reverse=True):
55
        avg_time = stats['total_time'] / stats['count']
56
        print(f"命令: {cmd}")
57
        print(f"  出现次数: {stats['count']}")
58
        print(f"  平均执行时间: {avg_time:.2f} μs")
59

60
        # 提供优化建议
61
        if cmd in ['KEYS', 'FLUSHALL', 'FLUSHDB']:
62
            print("  建议: 避免使用阻塞性命令")
63
        elif cmd == 'SORT':
64
            print("  建议: 考虑使用有序集合替代SORT操作")
65
        elif cmd in ['SUNION', 'SINTER', 'SDIFF']:
66
            print("  建议: 减少集合操作的数据量")
67
        print()

1
#!/bin/bash
2
# 内存使用分析脚本
3

4
analyze_memory_usage() {
5
    echo "=== Redis集群内存使用分析 ==="
6

7
    for node in "${nodes[@]}"; do
8
        IFS=':' read -ra ADDR <<< "$node"
9
        host=${ADDR[0]}
10
        port=${ADDR[1]}
11

12
        echo "节点: $host:$port"
13

14
        # 获取内存信息
15
        memory_info=$(redis-cli -h $host -p $port INFO memory)
16

17
        # 解析关键内存指标
18
        used_memory=$(echo "$memory_info" | grep "used_memory:" | cut -d: -f2 | tr -d '\r')
19
        used_memory_human=$(echo "$memory_info" | grep "used_memory_human:" | cut -d: -f2 | tr -d '\r')
20
        used_memory_peak=$(echo "$memory_info" | grep "used_memory_peak_human:" | cut -d: -f2 | tr -d '\r')
21
        mem_fragmentation_ratio=$(echo "$memory_info" | grep "mem_fragmentation_ratio:" | cut -d: -f2 | tr -d '\r')
22

23
        echo "  已使用内存: $used_memory_human"
24
        echo "  内存使用峰值: $used_memory_peak"
25
        echo "  内存碎片率: $mem_fragmentation_ratio"
26

27
        # 内存碎片率分析
28
        if (( $(echo "$mem_fragmentation_ratio > 1.5" | bc -l) )); then
29
            echo "  ⚠️  警告: 内存碎片率过高，建议重启节点"
30
        elif (( $(echo "$mem_fragmentation_ratio < 1.0" | bc -l) )); then
31
            echo "  ⚠️  警告: 可能存在内存交换，检查系统内存"
32
        else
33
            echo "  ✓ 内存碎片率正常"
34
        fi
35

36
        # 获取键空间统计
37
        keyspace_info=$(redis-cli -h $host -p $port INFO keyspace)
38
        if [ -n "$keyspace_info" ]; then
39
            echo "  键空间信息:"
40
            echo "$keyspace_info" | grep "^db" | while read line; do
41
                echo "    $line"
42
            done
43
        fi
44

45
        echo ""
46
    done
47
}
48

49
# 执行内存分析
50
nodes=("192.168.1.100:7000" "192.168.1.100:7001" "192.168.1.100:7002"
51
       "192.168.1.100:7003" "192.168.1.100:7004" "192.168.1.100:7005")
52
analyze_memory_usage