学习笔记

Redis

redis是三个key-value存款和储蓄系统,扶助存款和储蓄的value类型相对相当多,满含:string,list(链表),set(集结),zset(sorted
set —
有序聚集)和hash(哈希类型)。那些数据类型都帮忙push/pop,add/remove以致交并差集等丰硕的操作,何况那几个操作都以原子性的。在这里底蕴上redis补助各个差异排序的艺术。为了确定保证效能,数据是保存在内部存款和储蓄器中的。同一时候redis会周期性的把改过的数量写入磁盘恐怕把校订操作写入追加的笔录文件,並且在这里基本功上达成master-slave(主从State of Qatar同步

安装:

wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xzf redis-3.0.6.tar.gz
cd redis-3.0.6
make

 

启航服务端:

src/redis-server

 

起步顾客端:

src/redis-cli

 

使用:

127.0.0.1:6379> set name xiaoming
OK
127.0.0.1:6379> set age 22
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> get name
"xiaoming"
127.0.0.1:6379> get age
"22"

 

keys * :查看系统中存了某个个key

set key value:设置变量值;          set key value ex
2:设置变量,何况只好存活2分钟

 

python使用redis

安装redis模块:

sudo pip install redis
or
sudo easy_install redis

 

redis-py的API使用能够分为:

  连接形式,连接池,操作(String操作,Hash操作,List操作,Set操作,Sort
Set 操作),管道,公布订阅

1.操作方式

多少个类:Redis和StrictRedis用于落到实处redis命令,StrictRedis用于贯彻超级多合法的授命,并使用官方语法和指令,Redis是StrictRedis的子类,

import redis

r = redis.Redis(host='192.168.1.103',port=6379)
r.set('foo','Bar')
print(r.get('foo'))

 

2.连接池

redis-py使用连接池来管理对多少个redis
server的持有连接,幸免每便营造,释放连接的开辟。默许各样redis实例都会爱戴贰个和谐的连接池,能够平昔建构一个连接池,然后作为参数Redis,那样能够完结三个redis实例分享二个连接池

import redis
pool = redis.ConnectionPool(host = '192.168.1.103',port=6379)
r = redis.Redis(connection_pool=pool)
r.set('xu',123)
print(r.get('xu'))

 

3.操作

String操作,redis中的String在内部存款和储蓄器中依照key—value格局实行仓储:

set(name, value, ex=None, px=None, nx=False, xx=False):

在Redis中设置值,默认,不存在则创建,存在则修改
参数:
     ex,过期时间(秒)
     px,过期时间(毫秒)
     nx,如果设置为True,则只有name不存在时,当前set操作才执行
     xx,如果设置为True,则只有name存在时,岗前set操作才执行

setnx(name, value卡塔尔(قطر‎:设置值,只有name空头支票时,实施设置操作(增加)

setex(name,  time,value卡塔尔(قطر‎:设置值,time 过期时间,数字秒               
             psetex(name, time_ms, value):设置值,毫秒

mset(*args, **kwargs):

批量设置值
如:
    mset(k1='v1', k2='v2')
    或
    mget({'k1': 'v1', 'k2': 'v2'})

 

mget(keys, *args):

批量获取
如:
    mget('ylr', 'wupeiqi')
    或
    r.mget(['ylr', 'wupeiqi'])

getset(name, valueState of Qatar:设置新值并获得原本的值

getrange(key, start, end):

# 获取子序列(根据字节获取,非字符)
# 参数:
    # name,Redis 的 name
    # start,起始位置(字节)
    # end,结束位置(字节)
# 如: "ming" ,0-2表示 "min"

 

setrange(name, offset, value):

修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加)
# 参数:
    # offset,字符串的索引,字节(一个汉字三个字节)
    # value,要设置的值

setbit(name, offset, value):

对name对应值的二进制表示的位进行操作

参数:
    # name,redis的name
    # offset,位的索引(将值变换成二进制后再进行索引)
    # value,值只能是 1 或 0

注:如果在Redis中有一个对应: n1 = "foo",
        那么字符串foo的二进制表示为:01100110 01101111 01101111
    所以,如果执行 setbit('n1', 7, 1),则就会将第7位设置为1,
        那么最终二进制则变成 01100111 01101111 01101111,即:"goo"

在python中假使想要知道三个假名的二进制是有一些,能够先用ord(卡塔尔(قطر‎转为ASCII
值,然后在用bin(卡塔尔转变个方式二进制,然后从后往前数8位,不足补0,就是以此字母的二进制值

如何时候会用呢?

搜狐今日头条在线客户会有广大,纵然做多少深入分析,想要看眼下有啥样客户在线,用数据库的作用是不高的。大家先看一下和命令bitcount,用来计数变量的二进制中有几个1,如a:0b1100001,bitcount的结果正是3

bitcount(key, start=None, end=None)

获取name对应的值的二进制表示中 1 的个数
参数:
    # key,Redis的name
    # start,位起始位置
    # end,位结束位置

 

图片 1

那么数据库中种种顾客的id是无与伦比的,从1上马活动抬高,参预我们有2亿的顾客,有1亿在线,我们要总括那1亿顾客到底是何人在线,大家得以经过改二进制位来达成,即:
(n2是四个新的变量卡塔尔国

出席有二个客户id为1000的客户登陆,大家设置:setbit n2 1000 1
,又登陆了三个id为555的客商:setbit n2 555 1;客户id为6000的客商:setbit
n2 6000 1;大家用bitcount来造访n2:

图片 2

证实在线顾客有3个,那就得以完毕了总计了在线客户人数,然后我们要寻访毕竟是什么人在线了,客户id是稍微本人就取多少位,大家循环这些二进制的值就足以观察是对应的丰裕人在线,举例

咱俩想看客商55在不在线,我们用getbit:

图片 3

作者们想看看客商555在不在线:

图片 4

我们有2亿客户,最多也就占有2亿位,未有占多大空间,如若是用查看数据库的法子去看何人在线的话,那表的记录就老大大,查询起来也不行慢。

 

strlen(name卡塔尔国:重临name对应值的字节长度(二个汉字占3个字节)

incr(self, name, amount=1):

自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。
参数:
    # name,Redis的name
    # amount,自增数(必须是整数)

 decr(self, name, amount=1)

# 自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减。

# 参数:
    # name,Redis的name
    # amount,自减数(整数)

 

假若大家不想总括全体顾客在线的列表,你只想总计某个许顾客在线,这只必要贰个流速計,来八个加三个,相符也足以用redis实现,假如先来了叁个客商,我们就直接:

 图片 5

再来三个客商:

图片 6

所以直接来一一直:

图片 7

若是那一个客商掉线了,就用decr

图片 8

也正是说使用incr 和decr 能够达成自增自减

 

incrbyfloat(self, name, amount=1.0)

# 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。

# 参数:
    # name,Redis的name
    # amount,自增数(浮点型)

append(key, value):

# 在redis name对应的值后面追加内容

# 参数:
    key, redis的name
    value, 要追加的字符串

图片 9

 Hash操作,在redis中hash存在于内存中格式是那般的:

图片 10

hset(name, key, value)

# name对应的hash中设置一个键值对(不存在,则创建;否则,修改)

# 参数:
    # name,redis的name
    # key,name对应的hash中的key
    # value,name对应的hash中的value

# 注:
    # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建(相当于添加)

 图片 11

安装一个info变量,里面满含name,age,id 等key

 

hmset(name, mapping)

在name对应的hash中批量设置键值对

# 参数:
    # name,redis的name
    # mapping,字典,如:{'k1':'v1', 'k2': 'v2'}
# 如:
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

图片 12

 

hget(name,key):

在name对应的hash中获取根据key获取value

图片 13

获得info里面的name值和age值

 

hmget(name, keys, *args)

在name对应的hash中获取多个key的值

# 参数:
    # name,reids对应的name
    # keys,要获取key集合,如:['k1', 'k2', 'k3']
    # *args,要获取的key,如:k1,k2,k3

 图片 14

 

hgetall(name):获取name对应``hash``的所有键值

如获得info的具备键值:

图片 15

hlen(name卡塔尔国:获取name对应的hash中键值对的个数

图片 16

 

hkeys(name卡塔尔:获取name对应的hash中有所的key的值

图片 17

翻看那几个变量下的享有key,“属性”

 

hvals(name卡塔尔国:获取name对应的hash中保有的value的值

图片 18

 

hexists(name,
key):检查name对应的hash是或不是存在当前传播的key,如若存在再次来到1,不设有再次来到0

 

hdel(name,*keys卡塔尔国:将name对应的hash中内定key的键值对删除

hincrby(name, key, amount=1):

自增name对应的hash中的指定key的值,不存在则创建key=amount
# 参数:
    # name,redis中的name
    # key, hash对应的key
    # amount,自增数(整数)

hincrbyfloat(name, key, amount=1.0)

自增name对应的hash中的指定key的值,不存在则创建key=amount

# 参数:
    # name,redis中的name
    # key, hash对应的key
    # amount,自增数(浮点数)

# 自增name对应的hash中的指定key的值,不存在则创建key=amount

hscan(name, cursor=0, match=None, count=None)

增量式迭代获取,对于数据大的数据非常有用,hscan可以实现分片的获取数据,并非一次性将数据全部获取完,从而放置内存被撑爆

# 参数:
    # name,redis的name
    # cursor,游标(基于游标分批取获取数据)
    # match,匹配指定key,默认None 表示所有的key
    # count,每次分片最少获取个数,默认None表示采用Redis的默认分片个数

在hash中,贰个name能存200多亿个key,如若我们存了过多的key,然后经过hkeys
name收取数据,就能十分的快,那我们用hscan就起到三个过滤的效果。

图片 19

其一意思正是在info2中从第0个key带头相称到以k开始的键值对抽出来

图片 20

其一意思正是说想要把带有a的收取来

 

hscan_iter(name, match=None, count=None):

利用yield封装hscan创建生成器,实现分批去redis中获取数据

# 参数:
    # match,匹配指定key,默认None 表示所有的key
    # count,每次分片最少获取个数,默认None表示采用Redis的默认分片个数

# 如:
    # for item in r.hscan_iter('xx'):
    #     print item

 

list操作,redis中的list在内存中根据叁个name对应一个List来积累

图片 21

lpush(name,values)

# 在name对应的list中添加元素,每个新的元素都添加到列表的最左边

# 如:
    # r.lpush('oo', 11,22,33)
    # 保存顺序为: 33,22,11

# 扩展:
    # rpush(name, values) 表示从右向左操作

 图片 22

设置names列表,里面有3个因素,放在列表的最左侧

有lpush,就有rpush,正是存成分是身处列表的右端:rpush names xixi haha
hehe

图片 23

大家得以见到大家新存的xixi,haha,hehe是在背后依次贮存的

lpushx(name,value)

在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边

# 更多:
    # rpushx(name, value) 表示从右向左操作

 

llen(nameState of Qatar:name对应的list成分的个数

linsert(name,
where, refvalue, value)):

在name对应的列表的某一个值前或后插入一个新值

# 参数:
    # name,redis的name
    # where,BEFORE或AFTER
    # refvalue,标杆值,即:在它前后插入数据
    # value,要插入的数据

 图片 24

在names中往xiaoming前面插入meimei这一个新的因素

 

r.lset(name,
index, value):

对name对应的list中的某一个索引位置重新赋值

# 参数:
    # name,redis的name
    # index,list的索引位置
    # value,要设置的值

 图片 25

正是做三个改造数据的操作,把第6个因素改进值

 

r.lrem(name,
value, num):

在name对应的list中删除指定的值

# 参数:
    # name,redis的name
    # value,要删除的值
    # num,  num=0,删除列表中所有的指定值;
           # num=2,从前到后,删除2个;
           # num=-2,从后向前,删除2个

 图片 26

在linux中先数据要去除的个数,然后在输入删除的值

 

lpop(name):

在name对应的列表的左侧获取第一个元素并在列表中移除,返回值则是第一个元素

# 更多:
    # rpop(name) 表示从右向左操作

 图片 27

把names列表中的第贰个要素移出了

 

lindex(name,
index卡塔尔:在name对应的列表中依照目录获取列表成分

 

lrange(name,
start, end):

在name对应的列表分片获取数据
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

 图片 28

把names列表中存有的因素都抽出来正是0,-1.然后大家能够阅览大家前边存进去的先抽取来,表明列表是先入后出

 图片 29

获得names中从第二个到第八个因素,私下认可是从0算起的,

ltrim(name,
start, end):

在name对应的列表中移除没有在start-end索引之间的值
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

 图片 30

移出除了第2第多个要素之外的保有的要素

 

rpoplpush(src,
dst)

从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
# 参数:
    # src,要取数据的列表的name
    # dst,要添加数据的列表的name

 图片 31

把names中的最左边的xiaoming 移到了names2的最左侧

blpop(keys,
timeout):

将多个列表排列,按照从左到右去pop对应列表的元素

# 参数:
    # keys,redis的name的集合
    # timeout,超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞

# 更多:
    # r.brpop(keys, timeout),从右向左获取数据

 图片 32

把names中的数据每一回从左往右删除,假使names里面有成分就立刻删除,担任就等候4s。

那边有二个运用:笔者把时光设置成40,然后在开发银行一个redis客商端,然后在此40s以内自个儿在给names加多叁个新的成分,然后那边等待的客商端就立时把那一个值抽出来了

图片 33图片 34

不久前一定于运转了七个进度,三个可以后列表中放入值,贰个得以从列表中取值,有一点点像队列,想坐蓐者购买者,因为除去的时候会回到删除的值就约等于收取来数据

brpoplpush(src,
dst, timeout=0)

从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

# 参数:
    # src,取出并要移除元素的列表对应的name
    # dst,要插入元素的列表对应的name
    # timeout,当src对应的列表中没有数据时,阻塞等待其有数据的超时时间(秒),0 表示永远阻塞

 图片 35

固然把names2的元素移到names中,从右端移到了左端

 

自定义增量迭代

由于redis类库中没有提供对列表元素的增量迭代,如果想要循环name对应的列表的所有元素,那么就需要:
    # 1、获取name对应的所有列表
    # 2、循环列表
# 但是,如果列表非常大,那么就有可能在第一步时就将程序的内容撑爆,所有有必要自定义一个增量迭代的功能:

def list_iter(name):
    """
    自定义redis列表增量迭代
    :param name: redis中的name,即:迭代name对应的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in xrange(list_count):
        yield r.lindex(name, index)

# 使用
for item in list_iter('pp'):
    print item

 

Set操作,Set集结就是不一致敬再度的列表

图片 36

 

上海教室可以看见,作者往names中插入了6个值,不过在汇集中实际上就唯有3个值,所以说集结是不准再度的列表

sadd(name,valuesState of Qatar:name对应的聚合中添欧成分

scard(name卡塔尔(قطر‎: 获取name对应的汇集相月素的个数

sdiff(keys,
*args卡塔尔(قطر‎:在第一个name集合中且不再别的name对应的成团中的成分集结(差集:不含B集结成分的装有A成分)

图片 37

 

sdiffstore(dest,
keys,
*args卡塔尔(قطر‎:获取第叁个name对应的集聚中且别的不再name对应的集聚,再讲其参预新的dest集结中

图片 38

 

把差集的结果存到集结n6中,

sinter(keys,
*args卡塔尔国:(数学里的混合)

图片 39

 

sinterstore(dest,
keys, *args卡塔尔(قطر‎:获取集结之间的插花,再讲其参预到dest对应的集聚中

sismember(name,
value卡塔尔:检查value是或不是是name对应的聚众的成员

smembers(nameState of Qatar: 获取name对应的聚合的装有成员,集结不能够用切成片去取,因为它是冬天的

图片 40

得到集结names3的全数值

 

smove(src,
dst, valueState of Qatar:将某些成员从三个凑合中移动到其它二个汇合

spop(name卡塔尔国:从集结的入手(尾巴部分)移除叁个成员,并将其回到

srandmember(name,
numbers卡塔尔国:从name对应的集合中随机获取 numbers 个因素

srem(name,
valuesState of Qatar:在name对应的集纳中删去有些值

sunion(keys,
*args卡塔尔(قطر‎:获取多三个name对应的汇集的并集

sunionstore(dest,keys,
*args卡塔尔:获取多一个name对应的会集的并集,并将结果保存到dest对应的联谊中

sscan(name,
cursor=0, match=None, count=None)
sscan_iter(name,
match=None,
count=None卡塔尔(قطر‎:同字符串的操作,用于增量迭代分批获取成分,幸免内部存储器消耗太大

 

不改变集中,在汇集的底工上,为每成分排序;元素的排序要求依附别的三个值来进展比较,所以,对于有序聚焦,每叁个因素有四个值,即:值和分数,分数特地用来做排序。

zadd(name,
*args, **kwargs)

在name对应的有序集合中添加元素
# 如:
     # zadd('zz', 'n1', 1, 'n2', 2)
     # 或
     # zadd('zz', n1=11, n2=22)

 图片 41

给相应的要素设置权值,用来排序;先权值后值

 

zcard(name卡塔尔(قطر‎:获取name对应的坚持集合成分的数额 

zcount(name,
min, max卡塔尔国:获取name对应的不改变聚聚焦分数 在 [min,max] 之间的个数

zincrby(name,
value, amountState of Qatar:自增name对应的不改变集中的 name 对应的分数

r.zrange(
name, start, end, desc=False, withscores=False,
score_cast_func=float)

# 按照索引范围获取name对应的有序集合的元素

# 参数:
    # name,redis的name
    # start,有序集合索引起始位置(非分数)
    # end,有序集合索引结束位置(非分数)
    # desc,排序规则,默认按照分数从小到大排序
    # withscores,是否获取元素的分数,默认只获取元素的值
    # score_cast_func,对分数进行数据转换的函数

# 更多:
    # 从大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)

    # 按照分数范围获取name对应的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 从大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

 图片 42

图片 43

 

zrank(name,
value): 

获取某个值在 name对应的有序集合中的排行(从 0 开始)

# 更多:
    # zrevrank(name, value),从大到小排序

图片 44

zrangebylex(name, min, max, start=None, num=None)

# 当有序集合的所有成员都具有相同的分值时,有序集合的元素会根据成员的 值 (lexicographical ordering)来进行排序,而这个命令则可以返回给定的有序集合键 key 中, 元素的值介于 min 和 max 之间的成员
# 对集合中的每个成员进行逐个字节的对比(byte-by-byte compare), 并按照从低到高的顺序, 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话, 那么命令会认为较长的字符串比较短的字符串要大

# 参数:
    # name,redis的name
    # min,左区间(值)。 + 表示正无限; - 表示负无限; ( 表示开区间; [ 则表示闭区间
    # min,右区间(值)
    # start,对结果进行分片处理,索引位置
    # num,对结果进行分片处理,索引后面的num个元素

# 如:
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex('myzset', "-", "[ca") 结果为:['aa', 'ba', 'ca']

# 更多:
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

zrem(name, values)

# 删除name对应的有序集合中值是values的成员

# 如:zrem('zz', ['s1', 's2'])

zremrangebyrank(name, min, max卡塔尔:依照相排版行范围删除

zremrangebyscore(name, min, max卡塔尔国:依照分数范围删除

zremrangebylex(name, min, max卡塔尔国:依据值再次来到删除

zscore(name, valueState of Qatar:获取name对应有序集合中 value 对应的分数

zinterstore(dest, keys, aggregate=None):

# 获取两个有序集合的交集,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

zunionstore(dest, keys, aggregate=None):

# 获取两个有序集合的并集,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)

# 同字符串相似,相较于字符串新增score_cast_func,用来对分数进行操作

别的常用操作

delete(*namesState of Qatar:根据删除redis中的任性数据类型

exists(name卡塔尔(قطر‎: 质量评定redis的name是不是留存

keys(pattern=’*’):

# 根据模型获取redis的name

# 更多:
    # KEYS * 匹配数据库中所有 key 。
    # KEYS h?llo 匹配 hello , hallo 和 hxllo 等。
    # KEYS h*llo 匹配 hllo 和 heeeeello 等。
    # KEYS h[ae]llo 匹配 hello 和 hallo ,但不匹配 hillo

expire(name ,time卡塔尔(قطر‎:为某些redis的有个别name设置超时时间

rename(src, dst卡塔尔(قطر‎:对redis的name重命名称叫

move(name, db卡塔尔卡塔尔(قطر‎:将redis的某部值移动到钦定的db下

  redis暗许有拾七个db,从0-15 ,能够用select 进行切换

randomkey(卡塔尔:随机获得贰个redis的name(不删除)

type(name卡塔尔国:获取name对应值的花色

scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)

同字符串操作,用于增量迭代获取key

4.管道:

redis-py默许在施行每一遍央求都会创建(连接池申请连接)和断开(归还连接池)二次连续操作,假设想要在三次呼吁中钦点多少个指令,则足以接受pipline达成一回呼吁钦定五个指令,而且暗中同意境况下贰回pipline
是原子性操作。

import redis

pool = redis.ConnectionPool(host='192.168.1.101', port=6379)

r = redis.Redis(connection_pool=pool)

# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)

pipe.set('name', 'alex')
pipe.set('role', 'teacher')

pipe.execute()

 

5.揭露订阅

图片 45

那这一个怎么贯彻的吗?

 1 import redis
 2 class RedisHelper:
 3     def __init__(self):
 4         self.__conn = redis.Redis(host='192.168.1.101')
 5         self.chan_sub = 'fm104.7'
 6         self.chan_pub = 'fm104.7'
 7 
 8     def public(self, msg):
 9         self.__conn.publish(self.chan_pub, msg)
10         return True
11 
12     def subscribe(self):
13         pub = self.__conn.pubsub()#打开收音机
14         pub.subscribe(self.chan_sub)#调频道
15         pub.parse_response()#准备接收 
16         return pub

 订阅:

from RedisHelper import RedisHelper

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response()
    print(msg)

 

发布:

from RedisHelper import RedisHelper

obj = RedisHelper()
obj.public('hello,i am testing')

 

能够多个公布音信,通过同多个频道传给一人:

图片 46

 

缓存

比如说一个是QQ,三个是Wechat,我们想要完结双方的相互,大家事情未发生前学了rabbitMQ,能够兑现消息的传递;对于数据的分享,qq存款和储蓄的数额Wechat可以平素获得,那几个数量是投身内部存款和储蓄器中的,那大家怎么贯彻三个内部存款和储蓄器分享呢?大家要有三个承包商,经销商再运行二个独自的次第,本身开荒一块内部存款和储蓄器,QQ和承代理商创建三个socket,Wechat和南路商业创立二个socket,那样就得以完成了多中国少年共产党享。那一个代理商正是缓存。

主流的缓存:mongodb,redis,memcache。

我们都听过缓存,缓存是干啥的吧?大家得以和json和pickle来讲,多个程序之间达成音信相互,能够经过在A程序中把多少改成json
,然后传给B程序,通过文件这些媒质。文件这些效率极低。

前言:

发表评论

电子邮件地址不会被公开。 必填项已用*标注