Redis基础

2020-09-10

字数统计: 9.5k字 | 阅读时长≈ 43分

Redis基础

常识：

磁盘：

1.寻址 ms

2.带宽 (单位时间传多少个字节流) GB/MB

内存：

1寻址 ns

2.带宽速度一定比磁盘高的多，因为是直接跟cpu打交道的

磁盘在寻址上比内存慢10w倍

I/O buffer :成本问题

磁盘有

磁道和扇区：

一扇区512Byte 带来一个成本问题–》索引变大，成本变大

假如一个硬盘1T，那得有多少个512b，把这个硬盘当成容器，扇区为一个个小格子，那么要快速找到这个格子

操作系统就得给一个区间用来索引（索引就是下标，利于查找），格子一旦小，索引就会变大，那么可想而知，成本就太高了，

那么操作系统的解决方式：无论读多少数据，都是以最少4k来从磁盘拿，（用户即使只要1k，操作系统也会读4k，如果要5k，那么操作系统就会读8k，这样的好处就是大幅度减少索引）

——–

以前 ——->数据存在文件里data.txt

随着文件变大，速度变慢，

硬件决定了磁盘瓶颈，也就是I/O成为了数据读取的瓶颈

——》于是出现了数据库，数据存到数据库

那么数据库分了很多的 datapage（数据页）[每页4k，4k是为了不浪费I/O,因为上面说了，操作系统的一次I/O最少是4K,如果datapage不是4k的整数倍的话，其实就是浪费I/O],每页都会有id号

现在如果去查数据还是全量IO，因为想要的数据不知道在哪，

那么数据库就来了一个索引页的同样也是4K，索引放的就是datapage的一条数据的id号（就是唯一键，注意唯一键不是主键，而是每一条数据唯一的一个标志信息）和对应的datapage的id号

关系型数据库建表：必须给出schema（有多少列，每一列的数据类型，其实就是该表的结构是什么样）

列的类型：对应了字节宽度（约束该列只能存有多少字节）

给完列的类型后，他的存储是占行的形式（行级存储）

就是一行只放对应的一条数据（这样的好处就是，我的修改，不需要移动位置，只需对那一行操作就行）

索引和datapage都放在磁盘，那么在数据库这个软件在内存放了B+树用于数据查找

B+树

b+树的树叶就是索引，而树干（记录偏移量）是放在内存的

1570188042713

那么数据库的数据变大，表很大

如果表有索引—>对于增删改操作会变慢，因为要去维护索引

对查询来说—>如果是一个或少量查询，直接命中索引的那种，依然很快

——->但是对于并发大的时候会受硬盘的带宽的影响，速度会变慢，因为每次取4k走一次I/O进内存，下一条请求又是走一次I/O进内存，这里慢不是查询慢，而是I/O的速度慢，返回结果自然慢

既然这种主要存储在磁盘的数据库表变大，性能会变慢

那么另一个极端就是全部存到内存，（SAP HANA关系型数据库）

速度很快，但是成本太高，买不起

数据在内存和在磁盘的体积不一样

因为磁盘是没有指针概念的，不能很快的查到，所以需要索引，

但是进内存后就不需要索引了，那么自然体积会变小

2个基础设施

1.冯诺依曼体系的硬件

2以太网，tcp/ip的网络

限制了在硬件上的瓶颈

——-》引出了一种折中的方案，缓存的概念（memcached，redis）

https://db-engines.com/en/ 对市场数据引擎的评估

架构师：技术选型，产品选择

Redis

基于kv键值对内存存储的缓存数据库

支持秒级 10多万操作

redis.io 英文官方网站

redis.cn 中文官方网站

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。
它支持多种类型的数据结构，如字符串，散列（hashes），列表（lists），集合（sets），有序集合（sorted sets）与范围查询， bitmaps， hyperloglogs 和地理空间（geospatial）索引半径查询。
支持多种数据结构说的是value
Redis 内置了复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions）和不同级别的磁盘持久化（persistence），并通过 Redis哨兵（Sentinel）和自动分区（Cluster）提供高可用性（high availability）。

1570192810221

memcache也是K–V键值内存中的数据结构存储系统

memcache的V是没有类型的：

为什么redis会取代memcache？

世界上有3中数据表示：

k=a, k=1

k=[1,2,3],k=[a,b,c]

k=[x=y], k=[{} ,{} ,{} ]

json是可以表示很复杂的数据结构的。

那么memcache只要key–value，value存json来表示各种数据结构

为什么还火了一个redis，

redis的Value有类型的意义是什么：

1570192660013

计算向数据移动（就是计算不需要把数据拿回给客户端，而是直接在存数据的地方进行计算）

实操

redis 的类型描述在 Key里面，value还是以字节数组存（物理层次没有类型概念，逻辑层次才有），

基础环境，设施(需要哪些东西)：

centos 6.X，redis安装包

yum install wget -y

网上下载安装包

wget http://download.redis.io/releases/redis-5.0.4.tar.gz

tar xf redis…tar.gz //加不加-xf 无所谓，加v显示细节需要IO

yum install gcc -y

部署配置：

源码安装套路：

首先看readme

make distclean

make

make完之后，/root/soft/redis-5.0.4/src 里面就会有可执行程序

./redis-server 就会启动redis

如果要装成操作系统服务

1 make install PREFIX=/opt/bigdata/redis5

2 vi /etc/profile

export REDIS_HOME=/opt/bigdata/redis5
export PATH=$PATH:$REDIS_HOME/bin

. /etc/profile
echo $PATH

cd /root/soft/redis5.0.5/utils
./install_server.sh

会出现下面这句话，为该实例选一个端口号，那么对于同一台机器多个redis来说他们的区分就是靠端口号来区分的

不填的话默认端口号是6379

Please select the redis port for this instance: [6379]

选择完端口号之后，它默认会去/etc/redis/ 目录创建 6379.conf 文件，也就是说一台机器的多个redis可以通过不同的配置文件启动

Please select the redis config file name [/etc/redis/6379.conf]

定义号配置文件路径，下面就是日志文件路径，默认在/var/log/redis_6379.log

Please select the redis log file name [/var/log/redis_6379.log]

选择一个数据目录给当前的redis ，redis是一个内存数据库，为啥需要磁盘呢？

一般用内存存储的东西，都会有持久化的一个操作，工作虽然完全内存，那么要持久化就必须要磁盘

Please select the data directory for this instance [/var/lib/redis/6379]

给出redis可执行程序的路径，由于。/etc/profile文件里配了，所以自动识别到，。/etc/profile文件里如果没有配置，这里需要手敲路径

Please select the redis executable path [/opt/bigdata/redis5/bin/redis-server]

下面回车

把配置文件拷到了init.d目录，加了开机启动

Copied /tmp/6379.conf => /etc/init.d/redis_6379
Installing service…
Successfully added to chkconfig!
Successfully added to runlevels 345!
Starting Redis server…

然后就可以

service redis_6379 start|status|stop|restart

装第二个redis实例

cd /root/soft/redis5.0.5/utils/

./install_server.sh

Please select the redis port for this instance: [6379] 6380

Please select the redis config file name [/etc/redis/6380.conf]

Please select the redis log file name [/var/log/redis_6380.log]

Please select the data directory for this instance [/var/lib/redis/6380]

Please select the redis executable path [/opt/bigdata/redis5/bin/redis-server]

ps -ef |grep redis

一个物理机中可以有多个redis实例（进程），通过port区分

可执行程序就一份在目录，但是在内存中未来的多个实例需要各自的配置文件，持久化目录等资源

初始化运行

service redis_6379 start

概念

redis是单进程，单线程，单实例的

那么官网解释说可以10w多的请求并发，怎么做的？

客户端的请求一定发到操作系统内核

而redis 与操作系统kernel之间通信是epoll形式

采用I/O多路复用

—-BIO

1570247146964

于是内核kernel发生了变化 socket可以是nonbloking非阻塞—-》就是fd可以nonbloking

man 2 read Q退出

只要进程才会拥有文件描述符，文件本身不具备，（就是说，一次请求连接也是一个文件，那么进程要管理这个文件就必须打开一个文件描述符–去管理请求连接的那个文件）

0标准输入，1标准输出，2错误输出必备，对于网络IO会有255 广播

这种模型带来的问题

线程多了调度成本问题，cpu浪费

线程多，1000个线程都消耗1g内存

—-NIO

1570248392735

—–>带来了成本问题，就是用户端轮询fd，就会不断调用kernel拿fd出来看有没有数据

fd管理的那一个请求既然是一个文件，那就一定在磁盘，

而进程可以通过fd找到该文件，但是读不了，文件在磁盘，

只能内核来读，那就需要把fd传给内核，

内核有一个系统调用read可以通过fd找到文件并读数据

—于是内核又往前发展

增加了一个操作系统的调用select，

文件描述符是进程的东西（用户态|用户空间的东西），那么由进程把文件描述符传给kernel 的 select（nfds）

由内核去做轮询这些文件描述符

进程隔一段时间去访问内核select

内核会返回有数据的fds

有fds之后，然后进程调用read（fds）取出数据进行处理

1570249573661

—此时还是同步非阻塞的，只不过轮询给到了内核，少了一些进程调用内核的操作，

多路复用：a—-b有很多条路，但是有一条是或者有一段是可以复用的，复用的这一条路就是用户到内核读fd，怎么知道fd有没有数据的这条互不相同路交给kernel

用户态（空间），内核态（空间）

—引发了一个问题我的很多个fd需要传给内核，那就需要拷贝

此时拷贝的是内存的fd，

（fd不是具体请求数据，而是请求连接数据放在对应文件的描述）

对于程序来说速度要快，就尽力避免IO,也就是0拷贝，怎么样才能不需要把fd拷贝给内核

并且select模型一个进程的最大能打开的文件描述符是有限制的

———-》内核又改进，又增加了一个系统调用MMAP，epoll

这里用户进程在调用epoll时不会像调用select一样，把fd全部轮询一遍，即便是非阻塞也空轮询了，epoll会在每个fd上注册一个事件，有数据的fd就会回调，并写进mmap的链表，本身是多路复用型，一个伪的AIO

epoll对于一个进程文件描述符打开的限制大大的增加了

共享空间—-内核腾出一部分空间，对这部分空间做映射，也就是说用户那边也有一个这么大小的空间，用户空间地址为7映射到内核空间就是地址为8，

做这么一层映射，这样进程只需告诉内核地址空间fd的位置，内核就能找到

MMAP是用户态和内核态共享的一个空间，用户的连接fd用红黑树结构存储，操作系统内核操作链表结构存储有数据的fd，

1570258842081

—–》此时的文件描述符fd不需要拷贝，最终形态的多路复用NIO

还是同步非阻塞的

进程从链表里拿数据处理还是一条条来的

其实nginx也是这样 —–nginx会根据cpu个数来定义worker进程数—->每个worker进程用的都是epoll（）形式来管理连接—》同步非阻塞，多路复用。

是模拟的AIO,伪的，异步的地方在于内核对fd的判断方式，对于用户来说，还是同步非阻塞，

对于epoll模型，同样是IO的多路复用，但是只是对fd轮询做了修改，让活跃的fd回调，并入mmap的链表，进程拿到fd，还是要通过read（fd）来读取fd对应文件的数据，内核并不会先读好，而是进程主动调用IO 的read去读

进程主动去掉read，和内核已经读取完回调进程，直接copy，是区分NIO与AIO的一个关键点

共享空间的红黑树有内核维护

同步的意思是需要进程调用 wait（）阻塞了，有活跃才会返回，主动去共享空间链表拿fd，在去调用内核read方法拿到数据

异步的意思，就是不需要等待，有内核完成所有操作（包括读取fd对应文件的数据操作）给进程一个通知就行，很显然epoll不是异步的，epoll只是对fd的精准定位和快速返回，

对于进程IO来说，还需调用read获取数据

其实无论是 select epoll 都是需要客户端轮询去访问内核

select 是进程拿所有的fd 一次性压到内核，让内核返回有数据的fd

这个地方，用户是需要不断的去调用select，如果select返回了fd，就拿着fd去调用系统read（fd）获取数据

epoll 是每次来了一个fd就先注册进epollfd，让epollfd监听，此时虽然不需要每次传fd，但是需要进程轮询wait（）阻塞; 访问有没有活跃的fd，有活跃的fd然后调用read（fd）获取数据

最后两种方式，客户端轮询，客户端阻塞等待结果，其实就是同步

使用

1570260028969

客户端连接

命令行：

redis-cli //默认连6379redis实例

exit //客户端退出

redis-cli -h //看帮助

1570260422361

redis-cli -p 6380 //连接指定端口的redis实例

set k380:1 hello //设置键值对

get k380:1 //获取key对应得value

//默认是0号数据库

select 8 //进入redis 8号数据库

不同数据库之间得键值对不共享，是隔离的

也就是说我在执行get k380:1 是空nil

redis-cli -p 6380 -n 8//连接指定端口redis，并进入指定库

FLUSHDB//清库 –生产不要用

help @… //按tab键，显示不同的帮助文档

1570262617550

set xx xxx //key没有类型区分

String


127.0.0.1:6380[1]> set nihao hello
OK
127.0.0.1:6380[1]> get nihao
"hello"


SET key value [expiration EX seconds|PX milliseconds]（过期时间s|ms）    [NX|XX]
NX --->不存在才设置，存在key就不能设置（简单来说，NX只能新建）
127.0.0.1:6380[1]> set nihao xxoo NX
(nil)
127.0.0.1:6380[1]> get nihao
"hello"


XX --->存在才set（简单来说，XX只能更新）

127.0.0.1:6380[1]> set k1 hello XX
(nil)
127.0.0.1:6380[1]> get k1
(nil)


mset  ...{k,v}//设置多个kv，空格为间隔

127.0.0.1:6380[1]> mset k1 a k2 b
OK
127.0.0.1:6380[1]> get k1
"a"
127.0.0.1:6380[1]> get k2
"b"


mget  ...{k}  //一次获取多个key的值value
127.0.0.1:6380[1]> mget k1 k2
1) "a"
2) "b"


APPEND k  v   //追加
127.0.0.1:6380[1]> APPEND nihao " world"
(integer) 11
127.0.0.1:6380[1]> get nihao
"hello world"


GETRANGE k start end //去指定范围的数据
127.0.0.1:6380[1]> GETRANGE nihao 6 10 -->闭区间
"world"

1570263702615


"hello world"
127.0.0.1:6380[1]> GETRANGE nihao 6 -1
"world"

SETRANGE k  offset v  //从指定偏移量开始替换成v
127.0.0.1:6380[1]> SETRANGE nihao 6 zhangguangwei
(integer) 19
127.0.0.1:6380[1]> get nihao
"hello zhangguangwei"


STRLEN k   //指定k的长度
127.0.0.1:6380[1]> STRLEN nihao
(integer) 19


type k  //看类型


127.0.0.1:6380[1]> FLUSHALL
OK
127.0.0.1:6380[1]> set k1 hello
OK
127.0.0.1:6380[1]> set k2 99
OK
127.0.0.1:6380[1]> get k1
"hello"
127.0.0.1:6380[1]> get k2
"99"
127.0.0.1:6380[1]> type k1
string
127.0.0.1:6380[1]> type k2
string

OBJECT encoding k  //看k的编码
127.0.0.1:6380[1]> OBJECT encoding k1
"embstr"
127.0.0.1:6380[1]> OBJECT encoding k2
"int"

127.0.0.1:6380[1]> INCR k2  //INCR是++操作
(integer) 100
127.0.0.1:6380[1]> INCR k1
(error) ERR value is not an integer or out of range

//总结一点，在redis中value的 String是不字符串类型，而是一个对象，通过不同的编码来判断他是什么类型

INCRBY k increment //对于int类型k的v指定加多少
127.0.0.1:6380[1]> INCRBY k2 22
(integer) 122
127.0.0.1:6380[1]> get k2
"122"


DECR k   //编码为int的k的v进行--操作
127.0.0.1:6380[1]> DECR k2
(integer) 121

DECRBY k  decrement //对于int类型k的v指定减多少
127.0.0.1:6380[1]> DECRBY k2 22
(integer) 99

INCRBYFLOAT k increment//可以加小数
127.0.0.1:6380[1]> INCRBYFLOAT k2 0.5
"99.5"
//加完小数就会变成字符类型

GETSET k v //把旧值返回，新值设置进去，减少了一次io通信


MSETNX ...{(kv)} //有一个新增失败，都失败（多线程原子操作）

MSETXX ...{(kv)} //有一个修改失败，都失败（多线程原子操作）

1570278349445

1570265861530

key就是相当于对象，有type，encoding，有type可以避免错误类型计算，有encoding可以快速转换类型计算，不需要看是不是能转换

value只是字节数组

redis有一个二进制安全概念：就是把数据序列化成字节流，客户端以什么编码取，就以什么编码取出来，数据对不对要看与key的编码是否对上

（简单来说redis收到的是字节流，客户端以什么编码变成字节流发过来，redis就怎么存，要取得话也得跟原来编码一样，才能取出正确得数据，因为被序列化成字节了）

key上有encoding的信息就是对客户端传过来得数据类型进行一次预判断，（但是具体什么类型，跟客户端传过来有关【重点：redis只会收到客户端发过来得数据字节流，长度也是按字节来算，具体什么编码，redis不知道】）

域判断什么类型数据，主要方便计算int，或者string，这样就少几次取出字节数组看能不能转换这个过程，

例如：预判断为int的k，取出value直接转换成int ，不需要每次都去判断能不能转成int，然后再++等数值操作

这就是key里面要做类型预判断的好处

1570273817292

SETBIT offset value//offset是二进制位的offset，不是字节的

127.0.0.1:6379> SETBIT k1 1 1
(integer) 0
127.0.0.1:6379> STRLEN k1
(integer) 1
127.0.0.1:6379> get k1
"@"
0100 0000 ascii是@

127.0.0.1:6379> SETBIT k1 7 1
(integer) 0
127.0.0.1:6379> STRLEN k1
(integer) 1
127.0.0.1:6379> get k1
"A"
0100 0001 ascii是@

127.0.0.1:6379> SETBIT k1 9 1
(integer) 0
127.0.0.1:6379> STRLEN k1
(integer) 2
127.0.0.1:6379> get k1
"A@"
0100 0001 0100 0000 两个字节A@

常识：字符集 ascii

其他的都叫做扩展字符集

扩展字符集不会对ascii重编码

ascii 都是0xxx xxxx 看到0开头，直接ascii 解析

111x xxxx 这种，往后再读两个字节，因为是三字节编码

BITPOS k bit start end //start和end是字节索引，不是二进制位的
查找该范围内的【第一个】出现该二进制bit的   【二进制位的索引】
0100 0001 0100 0000
127.0.0.1:6379> BITPOS k1 1 0 0
(integer) 1

127.0.0.1:6379> BITPOS k1 1 1 1
(integer) 9

BITCOUNT k start end///start和end是字节索引
功能是做再该范围内二进制位为1的统计
127.0.0.1:6379> BITCOUNT k1 0 0
(integer) 2
127.0.0.1:6379> BITCOUNT k1 0 1
(integer) 3

BITOP operation destkey key [key ...]//operation 是与或非操作，destkey是操作完要存到的那个key，后面是说要哪些key参与运算操作
127.0.0.1:6379> SETBIT k1 1 1
(integer) 0
127.0.0.1:6379> SETBIT k1 7 1
(integer) 0
127.0.0.1:6379> get k1
"A"
127.0.0.1:6379> SETBIT k2 1 1
(integer) 0
127.0.0.1:6379> SETBIT k2 6 1
(integer) 0
127.0.0.1:6379> get k2
"B"
127.0.0.1:6379> BITOP | k1 k2
(error) ERR syntax error
127.0.0.1:6379> BITOP and andkey k1 k2
(integer) 1
127.0.0.1:6379> get andkey
"@"
127.0.0.1:6379> BITOP or orkey k1 k2
(integer) 1
127.0.0.1:6379> get orkey
"C"

--->redis的value 的String类型  最值钱的是bitmap

1需求：统计一个用户一年的登录次数
127.0.0.1:6379> SETBIT person 1 1-->用户第二天登录了
(integer) 0
127.0.0.1:6379> SETBIT person 9 1-->用户第10天登录了
(integer) 0
127.0.0.1:6379> SETBIT person 364 1---->用户第365天登录了
(integer) 0
127.0.0.1:6379> strl
(error) ERR unknown command `strl`, with args beginning with: 
127.0.0.1:6379> STRLEN person
(integer) 46
127.0.0.1:6379> BITCOUNT person 0 -1--> 一年的登录次数
(integer) 3

2：只需要最后一周该用户的登录次数
127.0.0.1:6379> BITCOUNT person -2 -1
(integer) 1


3需求：记录某时间段活跃用户，并统计个数

127.0.0.1:6379> SETBIT 20190101 0 1 //当天0号用户登录了
(integer) 0
127.0.0.1:6379> SETBIT 20190102 0 1//当天0号用户登录了
(integer) 0
127.0.0.1:6379> SETBIT 20190102 1 1//当天1号用户登录了
(integer) 0
127.0.0.1:6379> BITOP or destkey 20190101 20190102--》按位或去重
(integer) 1

127.0.0.1:6379> BITCOUNT destkey 0 -1--》统计20190101到20190102有多少个用户登录
(integer) 2

bitmap用矩阵形式来表述一些业务逻辑

key bitmap

xx 0 0 0 1 1 1

oo 0 1 0 1 1 0

zz 1 1 1 0 0 0

1570279086005

list

双向链表

1570279969257

1570283664686

LPUSH k v [v..] //从左边加 多个元素，每次从最左边加
127.0.0.1:6379> LPUSH k1 a b c d e f
(integer) 6
放到链表的采用的是头插法 lpush的结果 f e d c b a
1) "f"
2) "e"
3) "d"
4) "c"
5) "b"
6) "a"


RPUSH k v [v..] //每次从最右边加入，从而加入多个元素
127.0.0.1:6379> RPUSH k2 a b c d e f
(integer) 6
放到链表的采用的是尾插法 rpush的结果 a b c d e f
127.0.0.1:6379> LRANGE k2 0 -1
1) "a"
2) "b"
3) "c"
4) "d"
5) "e"
6) "f"




LPOP k  //对于该list类型的k ，从最左边弹出一个元素
127.0.0.1:6379> LPOP k1
"f"
RPOP k   //对于该list类型的k ，从最右边弹出一个元素
127.0.0.1:6379> RPOP k2
"f"




（LPUSH LPOP ）（RPUSH RPOP） 同向命令，描述了一个栈

（LPUSH RPOP ）（RPUSH LPOP））反向命令，描述了一个队列


LRANGE key start stop//看指定范围的元素，L是list类型的意思
127.0.0.1:6379> LRANGE k1 0 -1
1) "e"
2) "d"
3) "c"
4) "b"
5) "a"
//redis对list的每个元素也维护了一个正反向索引，于string对字节维护一个正反索引类似



LINDEX k index //查看对应下标的元素，并没有弹出
127.0.0.1:6379> LPUSH k1 a b c d e f
(integer) 6
127.0.0.1:6379> LRANGE k1 0 -1
1) "f"
2) "e"
3) "d"
4) "c"
5) "b"
6) "a"
127.0.0.1:6379> LINDEX k1 2
"d"
127.0.0.1:6379> LRANGE k1 0 -1
1) "f"
2) "e"
3) "d"
4) "c"
5) "b"
6) "a"


LSET key index value //list的set，把指定k，对应下标的值替换成value
127.0.0.1:6379> LSET k1 -3 cc
OK
127.0.0.1:6379> LRANGE k1 0 -1
1) "f"
2) "e"
3) "d"
4) "cc"
5) "b"
6) "a"

（LINDEX  LSET）  描述了对数组的操作


LREM k count value//list的remove，移除指定k 的value ，移除count个
127.0.0.1:6379> LPUSH k2 1 a 2 a 3 a
(integer) 6
127.0.0.1:6379> LRANGE k2 0 -1
1) "a"
2) "3"
3) "a"
4) "2"
5) "a"
6) "1"
127.0.0.1:6379> LREM k2 2 a
(integer) 2

127.0.0.1:6379> LRANGE k2 0 -1
1) "3"
2) "2"
3) "a"
4) "1"
count 为正数  从头来开始找到移除count个
count为0 移除全部a
count 为负数  从最后开始找到移除|count|个


LINSERT key after|before pivot value//list的insert，对于指定key，再对应pivot元素的after后面或者before前面，插入 value
127.0.0.1:6379> LINSERT k2 before 3 a
(integer) 5
127.0.0.1:6379> LINSERT k2 after 3 a
(integer) 6
127.0.0.1:6379> LRANGE k2 0 -1
1) "a"
2) "3"
3) "a"
4) "2"
5) "a"
6) "1"
//如果list有相同pivot的元素，那么从左到右找到第一个pivot元素为轴做LINSERT操作



BLPOP key [...key]  timeout//block 的LPOP，阻塞的弹出，
timeout设为0 会一直阻塞
假如没有k为 ooxx
127.0.0.1:6379> BLPOP ooxx 0
---阻塞中---
当其他客户端增加了一个ooxx的key
127.0.0.1:6379> LPUSH ooxx a b c
(integer) 3
阻塞的客户端立马会出现
1) "ooxx"
2) "c"
(89.37s)
注意：阻塞的客户端如果有多个，客户端拿到数据顺序 先进先出
--->谁先阻塞 数据到达 谁先拿数据



BLPOP BRPOP 描述一个阻塞的单播队列




LTRIM key start stop //保留start到stop（闭区间）的元素，删除两边的元素
127.0.0.1:6379> LPUSH k1 a b c d e f
(integer) 6
127.0.0.1:6379> LRANGE k1 0 -1
1) "f"
2) "e"
3) "d"
4) "c"
5) "b"
6) "a"
127.0.0.1:6379> LTRIM k1 2 3
OK
127.0.0.1:6379> LRANGE k1 0 -1
1) "d"
2) "c"

1570323753076

hash

map（k-v）

HSET k field value//放一个键值对进去
HGET k field  //查看一个键值对的value
127.0.0.1:6379> HSET k1 name zgw 
(integer) 1
127.0.0.1:6379> HGET k1 name
"zgw"

HMSET k field value[field value...]//放多个键值对进去
HMGET k field [field..]//查看多个键值对的value

127.0.0.1:6379> HMSET k1 age 18 address sh
OK
127.0.0.1:6379> HMGET k1 name  age address
1) "zgw"
2) "18"
3) "sh"

HKEYS k//查看所有field
127.0.0.1:6379> HKEYS k1
1) "name"
2) "age"
3) "address"

HVALS k//查看k对应所有键值对的value
127.0.0.1:6379> HVALS k1
1) "zgw"
2) "18"
3) "sh"

HGETALL k//查看k对应所有键值对的信息
127.0.0.1:6379> HGETALL k1
1) "name"
2) "zgw"
3) "age"
4) "18"
5) "address"
6) "sh"

HINCRBYFLOAT k field increment//对指定k的某一个键值对的value做+=increment操作   increment是浮点数也可以整数
//HHINCRBY 既支持整数计算，又支持浮点计算
127.0.0.1:6379> HINCRBYFLOAT k1 age 0.5
"18.5"
////
"25.5"
127.0.0.1:6379> HINCRBYFLOAT k1 age -5.5
"20"
//也可以减法


HINCRBY k field increment//对指定k的某一个键值对的value做+=increment操作   increment只能为整数
//HHINCRBY 只支持整数计算
127.0.0.1:6379> HINCRBY k1 age 2
(integer) 20
///
127.0.0.1:6379> HINCRBY k1 age -2
(integer) 18----》可以减法





HDEL k field[field...] //删除一个hash k的某一些键值对
127.0.0.1:6379> HDEL k1 name
(integer) 1
127.0.0.1:6379> HGETALL k1
1) "age"
2) "18"
3) "address"
4) "sh"


 HSETNX key field value
 不存在field字段才设置


  HSTRLEN key field
  指定k该field字段的value的字节长度
  127.0.0.1:6379> HSTRLEN k1 age
(integer) 2

  
  

HLEN key
有多少个字段，返回int

  HEXISTS key field
字段是否存在

1570328190738

Set

去除重复，无序


------增
SADD k member [member...] //添加一个或多个元素，即便有重复，他也会去重
127.0.0.1:6379> SADD k1 a a b b c c
(integer) 3
127.0.0.1:6379> SMEMBERS k1
1) "b"
2) "c"
3) "a"




  SMOVE source destination member
 元素从一个k到另一个k





----删

SREM k member [member...]//移除指定key的多个元素
127.0.0.1:6379> SREM k1 a d
(integer) 1
127.0.0.1:6379> SMEMBERS k1
1) "b"
2) "c"
//存在就移除，不存在不会报错，可能会影响性能


-----查


SCARD k //获得这个k的所有元素的数量

SISMEMBER k menber //查看集合是否有该元素

SMEMBERS k //获取所有的元素-->影响性能

  SSCAN key cursor [MATCH pattern] [COUNT count]
  summary: Incrementally iterate Set elements
  since: 2.8.0


------计算


SINTER k [k...]//多个k的value进行   交集运算,返回结果
127.0.0.1:6379> SADD k1 1 2 3 4 5
(integer) 5
127.0.0.1:6379> SADD k2 4 5 6 7 8
(integer) 5
127.0.0.1:6379> SINTER k1 k2
1) "4"
2) "5"


SINTERSTORE  destination k [k...]//多个k的value进行   交集运算，结果存入destination，
不返回结果，需要查看destination
127.0.0.1:6379> SINTERSTORE destkey k1 k2
(integer) 2
127.0.0.1:6379> SMEMBERS destkey
1) "4"
2) "5"
//带不带store设计的原因，完全是为了减少IO请求的次数



SUNION k [k..] //多个k的value进行   并集运算,返回结果
127.0.0.1:6379> SUNION k1 k2
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
7) "7"
8) "8"
SUNIONSTORE destination k [k...]//多个k的value进行        并集运算，结果存入destination，
不返回结果，需要查看destination

127.0.0.1:6379> SUNIONSTORE unionkey k1 k2
(integer) 8
127.0.0.1:6379> SMEMBERS unionkey
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
6) "6"
7) "7"
8) "8"




SDIFF k [k...]  ////多个k的value进行  差集运算,返回结果
127.0.0.1:6379> SDIFF k1 k2
1) "1"
2) "2"
3) "3"
127.0.0.1:6379> SDIFF k2 k1
1) "6"
2) "7"
3) "8"
//根据k的前后进行左差，右差运算



SRANDMEMBER key  count//随机事件
count为正整数，获得一个去重的结果集（不能超过已有的集）
127.0.0.1:6379> SRANDMEMBER k1 10
1) "1"
2) "2"
3) "3"
4) "4"
5) "5"
127.0.0.1:6379> SRANDMEMBER k1 3//小于所有元素，随机取出，并去重
1) "1"
2) "3"
3) "4"





count为负整数：获得一个带重复的结果集，一定满足你要的数量
127.0.0.1:6379> SRANDMEMBER k1 -10
 1) "2"
 2) "4"
 3) "3"
 4) "4"
 5) "3"
 6) "1"
 7) "4"
 8) "2"
 9) "5"
10) "5"
//随机取出，满足数量
127.0.0.1:6379> SRANDMEMBER k1 -3//小于所有元素，随机取出，不去重
1) "4"
2) "3"
3) "3"

count 0不返回
127.0.0.1:6379> SRANDMEMBER k1 0
(empty list or set)

----》场景
抽奖，用户放到set集合，  奖品count个数
用SRANGMEMBER 正数  每个用户只能抽一个，
负数，一个用户可以抽多个

sadd user a  b c d e d f//a，b.. 都是用户
SRANGMEMBER  user 3//3个奖品，每人最多只能1个
SRANGMEMBER  user -10//10个奖品，每人最多能抽到10个



SPOP k //随机弹出一个元素
127.0.0.1:6379> SPOP k1
"2"
127.0.0.1:6379> SPOP k1
"3"
127.0.0.1:6379> SPOP k1
"4"
127.0.0.1:6379> SPOP k1
"5"
127.0.0.1:6379> SPOP k1
"1"
127.0.0.1:6379> SPOP k1
(nil)

sorted_set

有序—>这个序是排序的意思

排序规则：既要给元素，又要给出score分值，先按分值排序，分值一样字典排序

有正负向索引，就可以对有序的元素进行正序，倒序

1570328884456

1570334396412

元素唯一

sort_set

有一个反向列表

和一个正向列表，

都有正反向索引

但是物理内存中是左小右大，不随命令改变

sort_Set 有元素，分值，排名

具备集合操作

排序的成本是什么


Z代表sorted_set,因为s被set用了

------增
 ZADD key [NX|XX] [CH] [INCR] score member [score member ...]
 NX加上一个或者多个元素进sort_set，或者XX已经存在就更新分值

127.0.0.1:6379> ZADD k1 8 apple 5 banana 3 oringe 
(integer) 3

再物理内存的摆放方式是  左边小  右边大
127.0.0.1:6379> ZRANGE k1 0 -1
1) "oringe"
2) "banana"
3) "apple"



-----删

  ZREM key member [member ...]
移除一个元素或多个元素

  ZREMRANGEBYRANK key start stop
  移除下标范围的所有元素

  ZREMRANGEBYSCORE key min max
  summary: Remove all members in a sorted set within the given scores
  移除所有在该分值内的元素

------改

  ZINCRBY key increment member
  对指定元素的分值进行数值运算
127.0.0.1:6379> ZRANGE k1 0 -1 withscores
1) "oringe"
2) "3"
3) "banana"
4) "5"
5) "apple"
6) "8"
浮点，整数都行
---加法
127.0.0.1:6379> ZINCRBY k1 2.5 oringe
"5.5"
127.0.0.1:6379> ZRANGE k1 0 -1 withscores
1) "banana"
2) "5"
3) "oringe"
4) "5.5"
5) "apple"
6) "8"
--减法
127.0.0.1:6379> ZINCRBY k1 -2.5 oringe
"3"
127.0.0.1:6379> ZRANGE k1 0 -1 withscores
1) "oringe"
2) "3"
3) "banana"
4) "5"
5) "apple"
6) "8"
------实时维护元素的排序




-----查

  ZCARD key
 获取所有元素的个数

 ZCOUNT key min max
  再该分值区间有多少个元素，min max表示分值

  ZRANGE key start stop [WITHSCORES]--》带分值的意思
获取该下标范围的所有元素，start ，stop 为正反向索引
127.0.0.1:6379> ZRANGE k1 0 -1 withscores
1) "oringe"
2) "3"
3) "banana"
4) "5"
5) "apple"
6) "8"

 ZREVRANGE key start stop [WITHSCORES]
 获取下标范围的所有元素，返回的元素分值是从高往低的
 127.0.0.1:6379> ZREVRANGE k1 0 1 withscores
1) "apple"
2) "8"
3) "banana"
4) "5"


ZSCORE key member
 获取该元素的分值

  ZRANK key member
该元素的正向下标--->这里不是索引
  ZREVRANK key member
该元素的反向下标--->这里不是索引
127.0.0.1:6379> ZRANK k1 apple
(integer) 2
127.0.0.1:6379> ZREVRANK k1 apple
(integer) 0


 ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]
获取 该分值范围内的所有元素，min，max代表分值，WITHSCORES返回是否带上分值，LIMIT分页


  ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]
 反向查询 该分值范围内的所有元素 max to min ，
 打印出来是高分到低分





  BZPOPMAX key [key ...] timeout
  summary: Remove and return the member with the highest score from one or more sorted sets, or block until one is available
   阻塞弹出分值最大

  BZPOPMIN key [key ...] timeout
  summary: Remove and return the member with the lowest score from one or more sorted sets, or block until one is available
  阻塞弹出分值最小


  ZLEXCOUNT key min max
  summary: Count the number of members in a sorted set between a given lexicographical range
  该字典范围内的元素数量

  ZPOPMAX key [count]
  summary: Remove and return members with the highest scores in a sorted set
 弹出分数最大的 count几个的意思


  ZPOPMIN key [count]
  summary: Remove and return members with the lowest scores in a sorted set
 弹出分数最小的 count几个的意思
 
 

  ZRANGEBYLEX key min max [LIMIT offset count]
  summary: Return a range of members in a sorted set, by lexicographical range
  //对该字典范围内的元素，按字典正向排序

  ZREMRANGEBYLEX key min max
  summary: Remove all members in a sorted set between the given lexicographical range
  删除给定字典范围内的排序集合中的所有成员


  ZREVRANGEBYLEX key max min [LIMIT offset count]
  summary: Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
  //对该字典范围内的元素，按字典反向排序


  ZSCAN key cursor [MATCH pattern] [COUNT count]
  summary: Incrementally iterate sorted sets elements and associated scores
 递增迭代集合元素和关联的分数





------计算
  ZUNIONSTORE destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM|MIN|MAX]
 多个sort set集合 并集，存入destination，
 numkeys是说有多少个k做运算，
 分值不同，元素名相同AGGREGATE规定怎么处理（sum分值和，mix分值取最小，max分值取最大），
 127.0.0.1:6379> ZADD k1 1 a 2 b 3 c
(integer) 3
127.0.0.1:6379> ZADD k2 3 a 4 d 5 e
(integer) 3
 127.0.0.1:6379> ZUNIONSTORE ukey 2 k1 k2
(integer) 5
 127.0.0.1:6379> ZRANGE ukey 0 -1 withscores
 1) "b"
 2) "2"
 3) "c"
 4) "3"
 5) "a"
 6) "4"
 7) "d"
 8) "4"
 9) "e"
10) "5"
----默认AGGREGATE=sum 相同元素不同分值做分值求和
---默认多个 k 的WEIGHTS 相等并且为1
127.0.0.1:6379> ZUNIONSTORE ukey1 2 k1 k2 weights 1 0.5
(integer) 5
127.0.0.1:6379> ZRANGE ukey1 0 -1 withscores
 1) "b"
 2) "2"
 3) "d"
 4) "2"
 5) "a"
 6) "2.5"
 7) "e"
 8) "2.5"
 9) "c"
10) "3"
WEIGHTS  分值*权重 是key 用来并交差计算 的分值



  ZINTERSTORE destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM|MIN|MAX]
交集运算  存入目标destination，numkeys多少个k比较
WEIGHTS 权重用于分值计算   AGGREGATE 分值最后的运算





------底层数据结构  skip list (跳跃表)-------------

1570333797039

典型的空间换时间的一种数据结构 skip list

元素量比较大时，速度平均值（增删改查）相对是最优的

本文作者： 忘忧症
本文链接： https://NepenthesZGW.github.io/2020/09/10/redis/redis基础/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！