0 redis为什么这么快
1 字符串类型
2 hash类型
3 列表类型
4 集合类型
5 有序集合
6 慢查询(排查reids慢的问题)
7 pipeline与事务
8 发布订阅
9 bitmap操作比特位
10 HyperLogLog算法
11 geo地理信息定位
0 redis为什么这么快
# 1 纯内存操作 避免io操作
# 2 单线程架构(数据读写) 避免了线程,进程间切换
# 3 使用了io多路复用网络模型
-io模型
-同步io
-异步io
-io多路复用
-poll
-epoll
-select
# 读写都是单线程---》不需要锁---》不会出现数据错乱
1 字符串类型
###1---基本使用get,set,del
get name #时间复杂度 o(1)
set name lqz #时间复杂度 o(1)
del name #时间复杂度 o(1)
###2---其他使用incr,decr,incrby,decrby
incr age #对age这个key的value值自增1
decr age #对age这个key的value值自减1
incrby age 10 #对age这个key的value值增加10
decrby age 10 #对age这个key的value值减10
#统计网站访问量(单线程无竞争,天然适合做计数器)
# 缓存mysql的信息(json格式)---》使用django的cache
#分布式id生成(多个机器同时并发着生成,不会重复) 时间戳+自增数字
###3---set,setnx,setxx
set name lqz #不管key是否存在,都设置
setnx name lqz #key不存在时才设置(新增操作)
set name lqz nx #同上
set name lqz xx #key存在,才设置(更新操作)
###4---mget mset
mget key1 key2 key3 #批量获取key1,key2.。。时间复杂度o(n)
mset key1 value1 key2 value2 key3 value3 #批量设置时间复杂度o(n)
#n次get和mget的区别
#n次get时间=n次命令时间+n次网络时间
#mget时间=1次网络时间+n次命令时间
###5---其他:getset,append,strlen
getset name lqznb #设置新值并返回旧值 时间复杂度o(1)
append name 666 #将value追加到旧的value 时间复杂度o(1)
strlen name #计算字符串长度(注意中文) 时间复杂度o(1) 字节长度
-字节
-字符:? 中 x
###6---其他:incrybyfloat,getrange,setrange
increbyfloat age 3.5 #为age自增3.5,传负值表示自减 时间复杂度o(1)
getrange key start end #获取字符串制定下标所有的值 时间复杂度o(1)
setrange key index value #从指定index开始设置value值 时间复杂度o(1)
# 最常见用途
- 缓存
- 计数器
2 hash类型
###1---hget,hset,hdel
hget key field #获取hash key对应的field的value 时间复杂度为 o(1)
hset key field value #设置hash key对应的field的value值 时间复杂度为 o(1)
hdel key field #删除hash key对应的field的值 时间复杂度为 o(1)
#测试
hset user:1:info age 23
hget user:1:info ag
hset user:1:info name lqz
hgetall user:1:info
hdel user:1:info age
###2---hexists,hlen
hexists key field #判断hash key 是否存在field 时间复杂度为 o(1)
hlen key #获取hash key field的数量 时间复杂度为 o(1)
hexists user:1:info name
hlen user:1:info #返回数量
###3---hmget,hmset
hmget key field1 field2 ...fieldN #批量获取hash key 的一批field对应的值 时间复杂度是o(n)
hmset key field1 value1 field2 value2 #批量设置hash key的一批field value 时间复杂度是o(n)
###4--hgetall,hvals,hkeys
hgetall key #返回hash key 对应的所有field和value 时间复杂度是o(n)
hvals key #返回hash key 对应的所有field的value 时间复杂度是o(n)
hkeys key #返回hash key对应的所有field 时间复杂度是o(n)
###小心使用hgetall
##其他操作 hsetnx,hincrby,hincrbyfloat
hsetnx key field value #设置hash key对应field的value(如果field已存在,则失败),时间复杂度o(1)
hincrby key field intCounter #hash key 对英的field的value自增intCounter 时间复杂度o(1)
hincrbyfloat key field floatCounter #hincrby 浮点数 时间复杂度o(1)
## 典型用途
##1 计算网站每个用户主页的访问量
hincrby user:1:info pageview count
##2 缓存mysql的信息,直接设置hash格式
##3 存储一组数据
3 列表类型
####### 插入操作
# 1 rpush 从右侧插入
rpush key value1 value2 ...valueN #时间复杂度为o(1~n)
# 2 lpush 从左侧插入
#3 linsert
linsert key before|after value newValue #从元素value的前或后插入newValue 时间复杂度o(n)
linsert listkey before b java
linsert listkey after b php
##### 删除操作
lpop key #从列表左侧弹出一个item 时间复杂度o(1)
rpop key #从列表右侧弹出一个item 时间复杂度o(1)
lrem key count value
ltrim 修剪 ltrim key start end #按照索引范围修剪列表 o(n)
#根据count值,从列表中删除所有value相同的项 时间复杂度o(n)
1 count>0 从左到右,删除最多count个value相等的项
2 count<0 从右向左,删除最多 Math.abs(count)个value相等的项
3 count=0 删除所有value相等的项
lrem listkey 0 a #删除列表中所有值a
lrem listkey -1 c #从右侧删除1个c
ltrim listkey 1 4 #只保留下表1--4的元素
### 查询操作
lrange key start end #包含end获取列表指定索引范围所有item o(n)
lrange listkey 0 2
lrange listkey 1 -1 #获取第一个位置到倒数第一个位置的元素
lindex key index #获取列表指定索引的item o(n)
lindex listkey 0
lindex listkey -1
llen key #获取列表长度
### 修改操作
lset key index newValue #设置列表指定索引值为newValue o(n)
lset listkey 2 ppp #把第二个位置设为ppp
### 其他操作
blpop key timeout #lpop的阻塞版,timeout是阻塞超时时间,timeout=0为拥有不阻塞 o(1)
brpop key timeout #rpop的阻塞版,timeout是阻塞超时时间,timeout=0为拥有不阻塞 o(1)
#要实现栈的功能
lpush+lpop
#实现队列功能
lpush+rpop
#固定大小的列表
lpush+ltrim
#消息队列
lpush+brpop
## 典型用途
实现timeLine功能,时间轴,微博关注的人,按时间轴排列,在列表中放入关注人的微博的即可
消息队列
栈
队列
4 集合类型
sadd key element #向集合key添加element(如果element存在,添加失败) o(1)
srem key element #从集合中的element移除掉 o(1)
scard key #计算集合大小
sismember key element #判断element是否在集合中
srandmember key count #从集合中随机取出count个元素,不会破坏集合中的元素 (抽奖)
spop key #从集合中随机弹出一个元素
smembers key #获取集合中所有元素 ,无序,小心使用,会阻塞住
sdiff user:1:follow user:2:follow #计算user:1:follow和user:2:follow的差集
sinter user:1:follow user:2:follow #计算user:1:follow和user:2:follow的交集
sunion user:1:follow user:2:follow #计算user:1:follow和user:2:follow的并集
sdiff|sinter|suion + store destkey... #将差集,交集,并集结果保存在destkey集合中
sdiffstore xxx number1 number2
SUNIONSTORE myset myset1 myset2
### 总结
### 实战
抽奖系统 :通过spop来弹出用户的id,活动取消,直接删除
点赞,点踩,喜欢等,用户如果点了赞,就把用户id放到该条记录的集合中
标签:给用户/文章等添加标签,sadd user:1:tags 标签1 标签2 标签3
给标签添加用户,关注该标签的人有哪些
共同好友:集合间的操作
# 总结4
sadd:可以做标签相关
spop/srandmember:可以做随机数相关
sadd/sinter:社交相关
5 有序集合
#### 特点 有一个分值字段,来保证顺序
key score value
user:ranking 1 lqz
user:ranking 99 lqz2
user:ranking 88 lqz3
#集合有序集合
集合:无重复元素,无序,element
有序集合:无重复元素,有序,element+score
#列表和有序集合
列表:可以重复,有序,element
有序集合:无重复元素,有序,element+score
# API使用 zset
zadd key score element #score可以重复,可以多个同时添加,element不能重复 o(logN)
zrem key element #删除元素,可以多个同时删除 o(1)
zscore key element #获取元素的分数 o(1)
zincrby key increScore element #增加或减少元素的分数 o(1)
zcard key #返回元素总个数 o(1)
zrank key element #返回element元素的排名(从小到大排)
zrange key 0 -1 #返回排名,不带分数 o(log(n)+m) n是元素个数,m是要获取的值
zrange player:rank 0 -1 withscores #返回排名,带分数
zrangebyscore key minScore maxScore #返回指定分数范围内的升序元素 o(log(n)+m) n是元素个数,m是要获取的值
zrangebyscore user:1:ranking 90 210 withscores #获取90分到210分的元素
zcount key minScore maxScore #返回有序集合内在指定分数范围内的个数 o(log(n)+m)
zremrangebyrank key start end #删除指定排名内的升序元素 o(log(n)+m)
zremrangebyrank user:1:rangking 1 2 #删除升序排名中1到2的元素
zremrangebyscore key minScore maxScore #删除指定分数内的升序元素 o(log(n)+m)
zremrangebyscore user:1:ranking 90 210 #删除分数90到210之间的元素
# 其他操作
zrevrank #从高到低排序
zrevrange #从高到低排序取一定范围
zrevrangebyscore #返回指定分数范围内的降序元素
zinterstore #对两个有序集合交集
zunionstore #对两个有序集合求并集
# 实战
排行榜:音乐排行榜,销售榜,关注榜,游戏排行榜
pyhton 100份
linux 30份
6 慢查询(排查reids慢的问题)
# 生命周期
客户端编写命令 get name---》通过网络 ---》到服务端---》服务端执行命令【查询,修改。。】---》返回数据通过网络返回给客户端
我们配置一个时间,如果查询时间超过了我们设置的时间,我们就认为这是一个慢查询.
慢查询发生在第三阶段
客户端超时不一定慢查询,但慢查询是客户端超时的一个可能因素
# 两个配置 配置慢查询
-只要是超过慢查询时间的命令,都会被记录
-后期通过记录分析,哪些命令是慢的,尽量在生成环境中避免
-慢查询是一个队列,里面记录了,超过你设定时间的命令
- 通过两个配置:
slowlog-log-slower-than 慢于多少微秒的都会被记录
slowlog-max-len 队列长度是多少
-配置文件直接配置
# 设置记录所有命令
config set slowlog-log-slower-than 0
# 最多记录100条
config set slowlog-max-len 100
# 持久化到本地配置文件
config rewrite
-查看慢查询队列
slowlog get 100
slowlog len #获取慢查询队列长度
slowlog reset #清空慢查询队列
7 pipeline与事务
# redis 其实不支持事务,但是可以通过pipeline来模拟事务,pipeline只支持但实例redis,如果做集群,没有pipeiline
### python客户端实现
import redis
pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
r = redis.Redis(connection_pool=pool)
# pipe = r.pipeline(transaction=False)
#创建pipeline
pipe = r.pipeline(transaction=True)
#开启事务
pipe.multi()
pipe.set('name', 'lqz')
#其他代码,可能出异常
pipe.set('role', 'nb')
pipe.execute()
####### 原生redis操作,模拟事务##########
# 0 开启两个客户端
# 在第一个客户端执行 mutil 开启事务,放到管道中一次性执行
multi # 开启事务
set name lqz
set age 18
exec
# 在第二个客户端去查询,如果第一个客户端没有执行exec ,查询不到第一个事务未提交的数据
########## 原生redis 通过watch+pipline(multi) 模拟乐观锁##########
###0 开启两个客户端
### 1 第一个客户端上 在开启事务之前,先watch
wathc age # 看了一眼,是88
multi
decr age # 它有可能被别人操作了
exec
# 另一台机器
mutil
decr age
exec # 先执行,上面的执行就会失败(乐观锁,被wathc的事务不会执行成功)
#### 集成到python项目中实现基于redi利用redis的乐观锁,实现秒杀系统的数据同步(基于watch实现),
import redis
conn = redis.Redis(host='127.0.0.1',port=6379)
# conn.set('count',1000)
with conn.pipeline() as pipe:
# 先监视,自己的值没有被修改过
conn.watch('count')
# 事务开始
pipe.multi()
old_count = conn.get('count')
count = int(old_count)
input('我考虑一下')
if count > 0: # 有库存
pipe.set('count', count - 1)
# 执行,把所有命令一次性推送过去
pipe.execute()
ret = pipe.execute()
print(type(ret))
print(ret)
## 用户二:
import redis
conn = redis.Redis(host='127.0.0.1',port=6379)
with conn.pipeline() as pipe:
# 先监视,自己的值没有被修改过
conn.watch('count')
# 事务开始
pipe.multi()
old_count = conn.get('count')
count = int(old_count)
if count > 0: # 有库存
pipe.set('count', count - 1)
# 执行,把所有命令一次性推送过去
ret=pipe.execute()
print(type(ret))
## 测试代码
import redis
from threading import Thread
def choose(name, conn):
# conn.set('count',10)
with conn.pipeline() as pipe:
# 先监视,自己的值没有被修改过
conn.watch('count')
# 事务开始
pipe.multi()
old_count = conn.get('count')
count = int(old_count)
# input('我考虑一下')
# time.sleep(random.randint(1, 2))
if count > 0: # 有库存
pipe.set('count', count - 1)
# 执行,把所有命令一次性推送过去
ret = pipe.execute()
print(ret)
if len(ret) > 0:
print('第%s个人抢购成功' % name)
else:
print('第%s个人抢购失败' % name)
if __name__ == '__main__':
conn = redis.Redis(host='127.0.0.1', port=6379)
for i in range(100):
t = Thread(target=choose, args=(i, conn))
t.start()
复制代码
8 发布订阅
# 发布者发布了消息,所有的订阅者都可以收到,就是生产者消费者模型(后订阅了,无法获取历史消息)
# 如果是消息队列
生产者生产了一条消息---》只会有一个消费者消费
# 如果是发布定义---》发布订阅---》观察者模式
生产者生产了一条消息---》所有订阅生产者的消费者都会收到消息
# 实际操作
-发布者发布消息
publish channel01 "hello world"
-订阅者01订阅频道 channel01
subscribe channel01
-订阅者02订阅频道 channel01
subscribe channel01
9 bitmap操作比特位
# 操作比特位
set hello big #放入key位hello 值为big的字符串
getbit hello 0 #取位图的第0个位置,返回0
getbit hello 1 #取位图的第1个位置,返回1 如上图
# 我们可以直接操纵位
setbit key offset value #给位图指定索引设置值
setbit hello 7 1 #把hello的第7个位置设为1 这样,big就变成了cig
# 独立用户统计---》统计日活---》用户量足够大--》节约内存
- 1 2 3 10亿
-使用集合存储---》1--》32位--》1亿用户 5千万左右---》需要 200MB空间
int8个比特位表示范围 -128--127之间
int16
int32 个比特位表示范围 -2的31次方---2的31次方 2147483648
-使用位图---》12.5MB空间
10 HyperLogLog算法
基于HyperLogLog算法:极小的空间完成独立数量统计,极小内存实现去重
pfadd urls "www.baidu.com" "www.cnblogs.com" "www.lqz.com"
pfcount urls
pfadd urls 值 # 返回0表示在,返回1 表示不在
# 总结
百万级别独立用户统计,百万条数据只占15k
错误率 0.81%
无法取出单条数据,只能统计个数
11 geo地理信息定位
# GEO(地理信息定位):存储经纬度,计算两地距离,范围等
# 经纬度如何获取?
-不是后端做的
-手机端---》手机有定位--》申请了定位---》手机端能拿到经纬度---》提供接口--->提交到后端
-web端---》js获取经纬度---》提供接口---》提交到后端
# 后端只需要存储
geoadd key longitude latitude member #增加地理位置信息
geoadd cities:locations 116.28 39.55 beijing #把北京地理信息天津到cities:locations中
geoadd cities:locations 117.12 39.08 tianjin
geoadd cities:locations 114.29 38.02 shijiazhuang
geoadd cities:locations 118.01 39.38 tangshan
geoadd cities:locations 115.29 38.51 baoding
# 统计两个经纬度距离
geodist cities:locations beijing baoding km
# 统计北京方圆 100公里内的城市
georadiusbymember cities:locations beijing 100 km