Redis快速入门指南(内附分布式锁实现过程)
Redis快速入门指南
文章向导
- Redis快速入门指南
- 一、redis 安装与配置
- 二、常用命令
- 三、redis常见数据类型以及用法
- 1. 字符串类型（string)
- 2.哈希类型(hash)
- 3.列表类型(list)
- 4.集合类型(set)
- 4.有序集合(sorted set)
- 三、对键(key)的整体操作
- 四、使用python操作Redis
- 1.安装第三方包
- 2.连接到Redis服务器
- 3.调用 API 操作 Redis
- 五、利用redis实现分布式锁
- 1.分布式锁原理
- 2.代码实现
一、redis 安装与配置
-
进入官网复制下载地址
官网地址
-
进入终端使用命令下载redis
wget http://download.redis.io/releases/redis-6.0.1.tar.gz -
进入文件下载的目录解压压缩包
tar -zxvf redis-6.0.1.tar.gz -C ./ # 创建一个软连接 ln -s redis-6.0.1 redis -
进入解压后的目录使用make命令进行编译
make MALLOC=libc注：如提示make命令不存在，可使用 sudo apt install make 自行安装，编译过程中如果少什么依赖根据报错提示自行安装即可。
-
安装redis到指定目录
cd ./src make install ``` 注：一定要先进入redis的src目录才可以执行make install 命令 -
配置redis
为了方便后续的管理，我们在redis的根目录中新建两个文件夹
mkdir etc mkdir bin将 redis/redis.conf 文件移动到新建的etc目录中
mv redis.conf etc/进入src目录将常用的二进制可执行文件拷贝到新建的bin目录中
cd redis/src ls -l | grep "^-rwx" | awk '{print $9}' | xargs -i cp {} ../bin/进入刚建的 etc 目录，然后打开编辑 redis.conf 文件
cd redis/etc vim redis.conf然后修改两个地方即可
# 绑定的地址 (默认是127.0.0.1，如只是本地访问就不需要修改) # ifconfig 查看自己的ip地址绑定即可 bind 192.168.96.131 # 配置启动方式为守护进程的方式启动，也就是后台启动 daemonize yes # 配置redis持久化的文件(这个目录需要自己提前创建) dir /home/hadoop/opt/redis/data # 配置连接密码(可要可不要,真实生产环境肯定还是必要的,但学习时可以图方便不设) requirepass 123456 # 配置文件中还有很多配置，可以自行按照需求对照官网的参数解释进行配置 -
启动后redis-server
# 使用刚才配置好的配置文件进行启动 redis-server etc/redis.conf # 查看服务是否启动成功 ps -xu | grep redis-server至此redis的环境配置完成
二、常用命令
- 先来看看自带的几个可执行文件的作用
| 文件名 | 主要功能 |
|---|---|
| redis-server | Redis服务的启动 |
| redis-cli | Redis的命令行客户端 |
| redis-benchmark | Redis性能测试客户端 |
| redis-check-aof | AOF文件修复工具 |
| redis-check-rdb | RDB文件检查工具 |
| redis-sentinel | Sentinel服务器的启动 |
-
先来介绍一下最常用的两个运维命令吧
（1）redis-server
刚在在安装时我们已经使用过这个命令了，我们先来来介绍一下它的一些常用参数；
# 就会罗列出这个命令的使用帮助 redis-server --help # 指定端口启动(redis 默认就是监听6379端口，可以自行更改) redis-server --port 6379 # 使用配置文件的方式启动 redis-server redis.conf（2）redis-cli
这个命令就比较重要了，使用它可以连接到我们的redis服务器。它提供了一个可交互的命令行窗口，我们可以在命令行做一些测试以及修改配置关闭服务器等等，总之非常的强大。
# 先列举一些简单的运维命令 # 连接前面我们启动的redis服务器 （如果端口和地址都是默认其实不填参数也行,如果设有密码加 -a 参数即可） redis-cli -h 192.168.96.131 -p 6379 # 关闭redis-server（平时建议使用此命令进行关闭服务， # 因为暴力关闭的化可能会造成数据还没来得急持久化， # 服务就被关闭了从而导致数据丢失) # 客户端连接后再输入命令 > SHUTDOWN # 查看连接是否正常 > PING # 打印一段文本类容 > ECHO 'hello world!' # 退出客户端(注意这里和关闭服务时有区别的,这里先当与只是断开了连接) > quit
三、redis常见数据类型以及用法
1. 字符串类型（string)
string是redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。
string类型是二进制安全的。意思是redis的string可以包含任何数据。比如jpg图片或者序列化的对象 。
string类型是Redis最基本的数据类型，一个键最大能存储512MB。
在需要使用命令前先提示一句（Rredis 的命令是不区分大小写的，但为了和键值进行区分还是把命令写成大写比较直观）
用法：
- 创建一个字符串类型的键
用法 SET [key] [value] [EX seconds | PX milliseconds]
> SET key1 "hello world!"
OK
- 读取刚才新建的这个键所对应的值
> GET key1
"hello world!"
- 再次设置同一个键就会自动覆盖前面的值
> SET key1 "override"
OK
- 设置键的过期时间
# 秒为单位:
> SET key1 "hello world!" EX 1
# 等一秒之后再获取值 (这个键时间已到期就被删除了)
> GET key1
(nil)
# 毫秒为单位:
> SET key1 "hello world!" PX 1000
OK
# 也是等一秒后再获取值,键也是时间到期就被删除
> GET key1
(nil)
- 将某个键对应的数组自增1(注意这个键对应的值必须是可以转为整数类型的)
用法: INCR [key]
> SET key1 1
OK
> INCR key1
(integer) 2
- 将某个键对应的数值自减1
用法: DECR [key]
> DECR
(integer) 1
- 将某个键的值增加指定的整数值
用法: INCRBY [key] [increment]
> INCRBY key1 10
(integer) 11
- 将某个键的值减少指定的整数值
用法: DECRBY [key] [decrement]
> DECRBY key1 10
(integer) 1
- 将某个键的值增加指定的浮点数值
用法: INCRBYFLOAT [key] [increment]
注意: 没有减少的方法,如需减少只需要再增长数值前加负号即可
> INCRBYFLOAT key1 0.5
"1.5"
> INCRBYFLOAT key1 -0.5
"1"
- 在字符串后面追加
用法: APPEND [key] [value]
# 返回值为追加字符串后,字符串的总长度
> APPEND key1 name
(integer) 5
> GET key1
"1name"
这里也只是笼统的介绍了一下常用的一些命令,命令还有很多就不依次列举了
2.哈希类型(hash)
Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。
Redis 中每个 hash 可以存储 2 32 − 1 2^{32}-1 232−1个键值对（40多亿）。
- 一次性创建多个键值对在一个实体中
用法: HMSET key field value [field value …]
# 创建一个学生'对象',姓名为Nick,年龄:18,性别:M
> HMSET student1 name "Nick" age 18 gender "M"
OK
- 获取刚创建的这个实体
用法: HGETALL key
> HGETALL student1
1) "name"
2) "Nick"
3) "age"
4) "18"
5) "gender"
6) "M"
- 获取实体的某一个属性值
用法: HMGET key field [field …]
> HMGET student1 name
1) "Nick
3.列表类型(list)
Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）
一个列表最多可以包含 2 32 − 1 2^{32} - 1 232−1 个元素 (4294967295, 每个列表超过40亿个元素)。
- 像一个键对应的列表的头部添加一个或多个元素(如果键不存在会自动创建)
用法: LPUSH key element [element …]
# 返回的整数代表,加入元素后列表的总长度
> LPUSH color red blue yellow green
(integer) 4
- 获取列表中的元素
用法: LRANGE key start stop
# 即使超过了列表的长度,也没关系
> LRANGE color 0 10
1) "green"
2) "yellow"
3) "blue"
4) "red"
- 从列表尾部插入一个或多个元素
用法: RPUSH key element [element …]
> RPUSH color white black pink
(integer) 7
> LRANGE color 0 10
1) "green"
2) "yellow"
3) "blue"
4) "red"
5) "white"
6) "black"
7) "pink"
4.集合类型(set)
Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。
Redis 中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。
集合中最大的成员数为 2 32 − 1 2^{32} - 1 232−1 (4294967295, 每个集合可存储40多亿个成员)。
- 向集合中添加元素
用法: SADD key member [member …]
# 返回的整数代表添加的个数
> SADD zoo1 tiger lion snake
(integer) 3
# 添加重复的元素看看
> SADD zoo1 snake
(integer) 0
- 显示集合中的所有元素
用法: SMEMBERS key
SMEMBERS1 zoo
1) "snake"
2) "tiger"
3) "lion"
- 获取多个集合的交集
用法: SINTER key [key …]
# 先在创建一个集合了来
> SADD zoo2 tiger lion cat dog
(integer) 4
# 求两个集合的交集
SINTER zoo1 zoo2
1) "tiger"
2) "lion"
- 获取多个集合的并集
用法: SUNION key [key …]
SUNION zoo1 zoo2
1) "lion"
2) "cat"
3) "snake"
4) "tiger"
5) "dog"
- 获取多个集合的差集
用法: SDIFF key [key …]
> SDIFF zoo1 zoo2
1) "snake"
4.有序集合(sorted set)
Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。
不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。
有序集合的成员是唯一的,但分数(score)却可以重复。
集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。 集合中最大的成员数为 2 32 − 1 2^{32} - 1 232−1 (4294967295, 每个集合可存储40多亿个成员)。
- 创建一个有序集合并添加元素
用法: ZADD key score member [score member …]
# 返回的也是添加的个数
> ZADD math_grade 88 "Nick" 99 "Alice" 55 "Tom"
(integer) 3
- 返回指定索引区间内的元素
用法: ZRANGE key start stop [WITHSCORES]
# WITHSCORES 的作用是将分数一并显示出来,可以不加
> ZRANGE math_grade 0 10 WITHSCORES
1) "Tom"
2) "55"
3) "Nick"
4) "88"
5) "Alice"
6) "99"
- 返回某个元素的分数
用法: ZSCORE key member
> ZSCORE math_grade Tom
"55"
- 计算指定分数段内的元素个数
用法: ZCOUNT key min max
> ZCOUNT math_grade 0 59
(integer) 1
- 通过分数返回有序集合指定区间内的元素
用法: ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
> ZRANGEBYSCORE math_grade 0 59
1) "Tom"
三、对键(key)的整体操作
- 查看已有的键
用法: KEYS pattern
pattern 支持模糊匹配,遵循glob风格
| 通配符 | 含义 |
|---|---|
| ? | 匹配一个任意字符 |
| * | 匹配任意多个任意字符 |
| [] | 匹配括号间的一个字符,可以用 ‘-’ 表示一个范围 |
| \ | 用于转义使用,如果要匹配 “?” 就可以使用 '?" 进行匹配 |
# 查看当前全部已经存在的键
> KEYS *
1) "zoo1"
2) "key1"
3) "math_grade"
4) "color"
5) "key2"
6) "zoo2"
7) "student1"
- 检查给定的 Key 是否存在
用法: EXISTS key [key …]
# 键存在返回 1,不存在返回 0
> EXISTS zoo1
(integer) 1
> EXISTS zoo3
(integer) 0
- 删除给定键
用法: DEL key [key …]
# 返回值为删除成功的键的个数
> DEL zoo1
(integer) 1
- 为某个键设置过期时间
用法: 秒:EXPIRE key seconds,毫秒:PEXPIRE key milliseconds
# 如果重复设置会覆盖之前的设置
# 返回值为 1 表示成功,0 为键不存在
> EXPIRE key1 60
(integer) 1
> PEXPIRE key1 1000
(integer) 1
- 产看键的剩余时间(也就是还有好久过期)
用法: 秒: TTL key, 毫秒: PTTL key
# 秒为单位
> EXPIRE zoo2 600
(integer) 1
> TTL zoo2
(integer) 597
# 毫秒为单位
> PTTL zoo2
(integer) 590512
- 清除过期时间,让键保持持久
用法: PERSIST key
> PERSIST zoo2
(integer) 1
# 返回负数表示不存在过期时间
> PTTL zoo2
(integer) -1
- 产看键对应的值的类型
用法: TYPE key
> TYPE color
list
> TYPE student1
hash
- 更改键名称
用法: RENAME key newkey
> keys *
1) "math_grade"
2) "color"
3) "key2"
4) "zoo2"
5) "student1"
> RENAME color colors
OK
> keys *
1) "colors"
2) "math_grade"
3) "key2"
4) "zoo2"
5) "student1"
四、使用python操作Redis
1.安装第三方包
安装非常简单只需要一条命令即可完成安装
pip install redis
2.连接到Redis服务器
redis 提供两个类 Redis 和 StrictRedis, StrictRedis 用于实现大部分官方的命令，Redis 是 StrictRedis 的子类，用于向后兼用旧版本。
- 方法一:
import redis
# decode_responses 的作用是将返回值进行解码,默认是返回字节类型
r = redis.Redis(host="192.168.96.131",
port=6379,
password="123456",
decode_responses=True)
- 方法二:
import redis
redis.StrictRedis(host="192.168.96.131",
port=6379,
password="123456",
decode_responses=True)
查看源码我们发现两个类的内部都实现了 "__enter__“和”__exit__"方法,也就意味着更推荐我们使用python的with方法来实例化连接对象,这样发生异常就会自动为我们断开连接,从不不占用连接数,示例如下:
import redis
with redis.StrictRedis(host="192.168.96.131",
port=6379,
password="123456",
decode_responses=True) as R:
pass
- redis 还提供了一个更高效的方法,也就是连接池 (这适用于高并发的系统,这样会减少很多连接和关闭带来的开销) 默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数传入Redis(或 StrictRedis)，这样就可以实现多个 Redis 实例共享一个连接池。
import redis
pool = redis.ConnectionPool(host="192.168.96.131",
port=6379,
password="123456",
decode_responses=True)
with redis.StrictRedis(connection_pool=pool) as r:
pass
3.调用 API 操作 Redis
-
python 的 redis 库操作redis很简单,几乎就和我们前面所学的命令行中的操作一致,就先讲一些基础常见的API使用方法吧,如有另外的需求可以去看官方文档;
注: 下文的 R 就代表我们的连接Reidis后的对象
-
set() 方法
参数对照表
| 参数名 | 作用 |
|---|---|
| name | key 的名称 |
| value | key 对应的值 |
| ex | 过期时间(秒) |
| px | 过期时间(毫秒) |
| nx | 如果设置为True，则只有name不存在时，当前set操作才执行 |
| xx | 如果设置为True，则只有name存在时，当前set操作才执行 |
示例:
# 创建一个字符串类型的 key-value 3秒后过期
R.set(name="test_key1", value="test",ex=3)
-
exists(*names)方法
传入一个键名或多个键名，返回是否存在这些键，如果存在就会返回True，如果不存在就会返回False
示例：
# 判断给定的键名是否已被创建
R.exists("test_key")
-
incr(name, amount=1)方法
将对应传入的键名对应的值自增,增加的值为amount的值,如果是键不存在,就会创建这个键,然后初始值就是amount的值,最后整个函数返回自增后值
示例:
# 创建或者增增一个键,自增的值为10
R.incr("test_incr",amount=10)
-
delete(*name)
根据传入的一个或者多个键名,然后再redis中删除这些键对应的键值对
示例:
# 删除两个键值对
R.delete("key1","key2")
-
expire(name,time)
将传入的键对应的键值对设置超时时间,如果到达超时时间,那么这个键值对就会自动删除,time为超时时间,单位为秒
示例:
# 将某个键设置10秒的超时时间
R.expire("test_key",time=10)
五、利用redis实现分布式锁
1.分布式锁原理
示意图:
-
我们的客户端首先发生并发任务,由于客户端需要的资源再整个集群中只有一件,这个资源在一个时间段内也只允许一个客户端使用.那么这些并发任务中的客户端就会去 ‘抢’ 这个资源,我们就要设定一个规则如果它们中有一个客户但一旦抢到了,那么就要通知其他的客户端资源已被占用,这时没抢到的客户端就会进入阻塞状态知道资源被释放,然后再开始竞争资源,整个锁的实现的详细流程就如下:
(1) 每个客户端向Redis中创建代表自己的键值对.键为整个Redis数据库中唯一的,且键是自增的(也就是先到的键就要小一点),
(2) 客户端再Redis中创建键值成功后,Redis会返回自己的键名给客户端,从图中可以看到:客户端1创建的键为002,客户端2创建的键为001,客户端3创建的键为003.
(3) 然后客户端会进行’自我检查’,判断自己注册的键是否为最小的,如果是就表示自己抢夺资源成功,然后立刻就就要设置自己在Redis上注册的这个键的过期时间.
(4) 其他没有抢夺成功的客户端就会监听比自己键小 1 的键,如果这个键消失了,就表示资源已被释放,那么自己就可以占用这个资源了.就图中而言:我们的锁被客户端2占用,这时客户端1监听客户端2,客户端3监听客户端1.
(5) 一直往返执行步骤 (4),知道所有客户端都已使用资源
(6) 此次并发任务结束
2.代码实现
import redis
import time
import threading
LOCK_ACCESS_ID = "lock:access:id"
LOCK_REGISTER_KEY = "lock:register:id:"
redis_pool = redis.ConnectionPool(host="192.168.96.131",
port=6379,
password="123456",
decode_responses=True)
class DistributedLock(object):
def __init__(self, pool):
self.redis_connect = redis.StrictRedis(connection_pool=pool)
self.my_key = None
def get_lock(self, timeout=10):
"""
desc: 获取锁
:param timeout:获取锁之后的最大占用时间
:return: None
"""
# 向 redis 获取注册的 id (使用 lua 脚本执行从而实现原子性)
register_lock_lua = """
local register_id = redis.call("incr", KEYS[1])
redis.call("set",KEYS[2]..register_id,register_id)
return register_id
"""
# 初始化注册锁id的脚本
register_lock_id_script = self.redis_connect.register_script(register_lock_lua)
# 向脚本中传入参数，并执行脚本，返回注册的 锁id
lock_id = register_lock_id_script(keys=[LOCK_ACCESS_ID, LOCK_REGISTER_KEY])
# 初始化自己的锁对应的键名
self.my_key = "".join([LOCK_REGISTER_KEY, str(lock_id)])
# 当前自己需要监听的节点
listen_key = "".join([LOCK_REGISTER_KEY, str(lock_id - 1)])
# 判断监听的锁是否存在，如果已经消失则自己获得锁
# 并将自己对应在redis上的键值对设置过期时间
listen_lua = """
local exists = redis.call("exists", KEYS[1])
if exists then
redis.call("expire",KEYS[2],ARGV[1])
end
return exists
"""
listen_key_script = self.redis_connect.register_script(listen_lua)
# 判断比自己小 1 的键是否存在，如果存在就阻塞
while listen_key_script(keys=[listen_key, self.my_key], args=[timeout]):
time.sleep(1)
# print("do something")
def release(self):
# 判断自己注册的键是否还存在
if self.redis_connect.exists(self.my_key):
# 如果存在就删除这个键，表示主动释放锁
self.redis_connect.delete(self.my_key)
else:
# 如果键已经不存在了，那么表示我们的锁已经超时，资源被自动释放了
print("超时释放")
def close(self):
self.redis_connect.close()
# 定义装饰器，是得我们的锁的使用更加灵活
def add_lock(pool):
def wrapper1(func):
def wrapper2(*args, **kwargs):
dl = DistributedLock(pool)
try:
dl.get_lock()
func(*args, **kwargs)
finally:
dl.release()
dl.close()
return wrapper2
return wrapper1
# 调用装饰器，代表被装饰的这个函数需要锁
@add_lock(redis_pool)
def task(n):
print(f"task{n}xec")
time.sleep(2)
if __name__ == '__main__':
# 使用对线程模拟分布式环境的并发
task_pool = []
for i in range(10):
threading.Thread(target=task, args=(i,)).start()
y):
# 如果存在就删除这个键，表示主动释放锁
self.redis_connect.delete(self.my_key)
else:
# 如果键已经不存在了，那么表示我们的锁已经超时，资源被自动释放了
print("超时释放")
def close(self):
self.redis_connect.close()
# 定义装饰器，使得我们的锁的使用更加灵活
def add_lock(pool):
def wrapper1(func):
def wrapper2(*args, **kwargs):
dl = DistributedLock(pool)
try:
dl.get_lock()
func(*args, **kwargs)
finally:
dl.release()
dl.close()
return wrapper2
return wrapper1
# 调用装饰器，代表被装饰的这个函数需要锁
@add_lock(redis_pool)
def task(n):
print(f"task{n}xec")
time.sleep(2)
if __name__ == '__main__':
# 使用对线程模拟分布式环境的并发
task_pool = []
for i in range(10):
threading.Thread(target=task, args=(i,)).start()