3-redis高级-为什么这么快和慢查询、(字符串、hash类型、列表、集合、有序集合)、pipeline与事务、发布订阅、bitmap操作比特位、geo地理信息定位、HyperLogLog算法

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