Redis核心数据结构与分布式锁实现详解

用户8589624

发布于 2025-11-16 09:41:06

1050

文章被收录于专栏：nginxnginx

Redis核心数据结构与分布式锁实现详解

一、Redis简介与数据结构概述

Redis（Remote Dictionary Server）是一个开源的、基于内存的高性能键值存储系统，它支持多种数据结构，并提供了丰富的操作命令。由于其出色的性能和丰富的功能，Redis被广泛应用于缓存、消息队列、会话存储、排行榜等场景。

Redis之所以如此受欢迎，主要得益于以下几个特点：

内存存储：数据主要存储在内存中，读写速度极快
数据结构丰富：不仅支持简单的字符串，还支持列表、集合、哈希等复杂结构
持久化支持：可以将内存数据定期保存到磁盘
高可用性：支持主从复制和集群模式
原子性操作：所有操作都是原子性的

二、Redis常用数据结构详解

1. 字符串(String)

字符串是Redis最基本的数据类型，可以存储文本、数字或二进制数据，最大能存储512MB。

常用命令：

SET key value [EX seconds] [PX milliseconds] [NX|XX]
GET key
INCR key
DECR key
APPEND key value
STRLEN key

应用场景：

缓存HTML片段或页面
计数器
存储用户会话信息

示例代码：

import redis

r = redis.Redis(host='localhost', port=6379, db=0)

# 设置和获取字符串
r.set('username', 'john_doe')
print(r.get('username'))  # 输出: b'john_doe'

# 计数器
r.set('page_views', 0)
r.incr('page_views')
print(r.get('page_views'))  # 输出: b'1'

2. 哈希(Hash)

哈希是字段和值的映射表，特别适合存储对象。

常用命令：

HSET key field value
HGET key field
HGETALL key
HDEL key field
HKEYS key
HVALS key

应用场景：

存储用户信息（姓名、年龄、地址等）
存储产品属性

示例代码：

# 存储用户信息
r.hset('user:1000', 'name', 'Alice')
r.hset('user:1000', 'age', 25)
r.hset('user:1000', 'email', 'alice@example.com')

# 获取所有字段
print(r.hgetall('user:1000'))  
# 输出: {b'name': b'Alice', b'age': b'25', b'email': b'alice@example.com'}

# 获取单个字段
print(r.hget('user:1000', 'name'))  # 输出: b'Alice'

3. 列表(List)

列表是简单的字符串列表，按照插入顺序排序，可以从头部或尾部添加元素。

常用命令：

LPUSH key value [value ...]
RPUSH key value [value ...]
LPOP key
RPOP key
LRANGE key start stop
LLEN key

应用场景：

消息队列
最新消息排行
记录用户最近的操作

示例代码：

# 作为消息队列使用
r.lpush('task_queue', 'task1')
r.lpush('task_queue', 'task2')
r.lpush('task_queue', 'task3')

# 获取队列长度
print(r.llen('task_queue'))  # 输出: 3

# 消费消息
task = r.rpop('task_queue')
print(task)  # 输出: b'task1'

4. 集合(Set)

集合是字符串的无序集合，不允许重复元素。

常用命令：

SADD key member [member ...]
SREM key member [member ...]
SMEMBERS key
SISMEMBER key member
SCARD key
SINTER key [key ...]  # 交集
SUNION key [key ...]  # 并集
SDIFF key [key ...]   # 差集

应用场景：

标签系统
好友关系
唯一IP统计

示例代码：

# 标签系统
r.sadd('article:123:tags', 'python', 'programming', 'database')

# 检查标签是否存在
print(r.sismember('article:123:tags', 'python'))  # 输出: True

# 获取所有标签
print(r.smembers('article:123:tags'))  
# 输出: {b'python', b'database', b'programming'}

5. 有序集合(Sorted Set)

有序集合类似于集合，但每个元素都关联一个分数(score)，元素按分数排序。

常用命令：

ZADD key score member [score member ...]
ZRANGE key start stop [WITHSCORES]
ZREVRANGE key start stop [WITHSCORES]
ZRANK key member
ZSCORE key member
ZCARD key

应用场景：

排行榜
带权重的队列
范围查找

示例代码：

# 排行榜
r.zadd('game_scores', {'Alice': 1500, 'Bob': 1200, 'Charlie': 1800})

# 获取前三名
top_players = r.zrevrange('game_scores', 0, 2, withscores=True)
print(top_players)  
# 输出: [(b'Charlie', 1800.0), (b'Alice', 1500.0), (b'Bob', 1200.0)]

# 获取某个玩家的排名(从0开始)
print(r.zrevrank('game_scores', 'Alice'))  # 输出: 1

6. 其他数据结构

Redis还支持一些特殊的数据结构：

HyperLogLog 用于基数统计，提供不精确的去重计数方案。

Geo 用于存储地理位置信息，支持半径查询等操作。

Bitmaps 通过位操作实现一些特殊功能，如用户签到统计。

三、Redis实现分布式锁

1. 分布式锁的概念与需求

在分布式系统中，当多个进程或服务需要互斥地访问共享资源时，就需要分布式锁。分布式锁需要满足以下几个基本要求：

互斥性：同一时刻只有一个客户端能持有锁
避免死锁：即使持有锁的客户端崩溃，锁也能被释放
容错性：只要大部分Redis节点正常运行，客户端就能获取和释放锁
自旋等待：获取不到锁的客户端应该能等待并重试

2. 基于Redis的分布式锁实现方案

方案一：使用SETNX命令（基本实现）

def acquire_lock(conn, lock_name, acquire_timeout=10):
    identifier = str(uuid.uuid4())
    lock_key = f'lock:{lock_name}'
    end = time.time() + acquire_timeout
    
    while time.time() < end:
        if conn.setnx(lock_key, identifier):
            return identifier
        time.sleep(0.001)
    return False

def release_lock(conn, lock_name, identifier):
    lock_key = f'lock:{lock_name}'
    with conn.pipeline() as pipe:
        while True:
            try:
                pipe.watch(lock_key)
                if pipe.get(lock_key) == identifier.encode():
                    pipe.multi()
                    pipe.delete(lock_key)
                    pipe.execute()
                    return True
                pipe.unwatch()
                break
            except redis.exceptions.WatchError:
                pass
        return False

问题：

如果客户端在获取锁后崩溃，锁永远不会被释放
没有重入机制
锁的获取和释放不是原子操作

方案二：使用SET命令带过期时间（改进版）

def acquire_lock(conn, lock_name, acquire_timeout=10, lock_timeout=10):
    identifier = str(uuid.uuid4())
    lock_key = f'lock:{lock_name}'
    lock_timeout = int(lock_timeout)
    
    end = time.time() + acquire_timeout
    while time.time() < end:
        if conn.set(lock_key, identifier, ex=lock_timeout, nx=True):
            return identifier
        time.sleep(0.001)
    return False

def release_lock(conn, lock_name, identifier):
    lock_key = f'lock:{lock_name}'
    script = """
    if redis.call("get", KEYS[1]) == ARGV[1] then
        return redis.call("del", KEYS[1])
    else
        return 0
    end
    """
    result = conn.eval(script, 1, lock_key, identifier)
    return bool(result)

改进点：

使用SET命令的NX和EX参数替代SETNX，实现原子性设置值和过期时间
使用Lua脚本保证释放锁的原子性
添加了锁的超时机制，防止死锁

方案三：Redlock算法（集群环境）

在Redis集群环境下，为了确保锁的高可用性，可以使用Redlock算法：

获取当前时间（毫秒）
依次尝试从N个独立的Redis实例获取锁
计算获取锁花费的总时间，如果小于锁的过期时间，并且从大多数(N/2+1)实例获取成功，则获取锁成功
锁的实际有效时间 = 初始有效时间 - 获取锁花费的时间
如果获取锁失败，则向所有实例发送释放锁命令

Python实现示例：

import random
import time

def acquire_redlock(conns, lock_name, ttl, retry_count=3, retry_delay=0.2):
    quorum = len(conns) // 2 + 1
    identifier = str(uuid.uuid4())
    
    for _ in range(retry_count):
        start_time = time.time() * 1000
        acquired = 0
        for conn in conns:
            try:
                if conn.set(lock_name, identifier, nx=True, px=ttl):
                    acquired += 1
            except redis.RedisError:
                continue
        
        elapsed = time.time() * 1000 - start_time
        if acquired >= quorum and elapsed < ttl:
            return {
                'validity': ttl - elapsed,
                'resource': lock_name,
                'identifier': identifier
            }
        
        # 释放已经获取的锁
        for conn in conns:
            try:
                conn.eval("""
                if redis.call("get", KEYS[1]) == ARGV[1] then
                    return redis.call("del", KEYS[1])
                else
                    return 0
                end
                """, 1, lock_name, identifier)
            except redis.RedisError:
                pass
        
        time.sleep(retry_delay * (1 + random.random()))
    
    return False

def release_redlock(conns, lock_info):
    if not lock_info:
        return
    
    for conn in conns:
        try:
            conn.eval("""
            if redis.call("get", KEYS[1]) == ARGV[1] then
                return redis.call("del", KEYS[1])
            else
                return 0
            end
            """, 1, lock_info['resource'], lock_info['identifier'])
        except redis.RedisError:
            pass