模块-Memcached、Redis

时间  2019-11-17
标签 模块 memcached redis 栏目 Memcached 繁體版
原文   原文链接

目录

Mecachejavascript

Redishtml

Memcached

Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它经过在内存中缓存数据和对象来减小读取数据库的次数，从而提升动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程（daemon ）是用C写的，可是客户端能够用任何语言来编写，并经过memcached协议与守护进程通讯。java

Memcached安装

Memcached安装：python

1
2
3
4
5
6
7
8
wget http: / / memcached.org / latest
tar  - zxvf memcached - 1.x .x.tar.gz
cd memcached - 1.x .x
. / configure && make && make test && sudo make install
 
PS：依赖libevent
        yum install libevent - devel
        apt - get install libevent - dev

启动Memcachedlinux

1
2
3
4
5
6
7
8
9
10
memcached  - d  - m  10     - u root  - l  10.211 . 55.4  - p  12000  - c  256  - P  / tmp / memcached.pid
 
参数说明:
     - d 是启动一个守护进程
     - m 是分配给Memcache使用的内存数量，单位是MB
     - u 是运行Memcache的用户
     - l 是监听的服务器IP地址
     - p 是设置Memcache监听的端口,最好是 1024 以上的端口
     - c 选项是最大运行的并发链接数，默认是 1024 ，按照你服务器的负载量来设定
     - P 是设置保存Memcache的pid文件

Memcached命令git

1
2
3
存储命令:  set / add / replace / append / prepend / cas
获取命令: get / gets
其余命令: delete / stats..

Python操做Memcachedgithub

安装APIredis

1
2
python操做Memcached使用Python - memcached模块
下载安装：https: / / pypi.python.org / pypi / python - memcached

 

使用

一、第一次操做算法

1
2
3
4
5
6
import  memcache
 
mc  =  memcache.Client([ '10.211.55.4:12000' ], debug = True )
mc. set ( "foo" ,  "bar" )
ret  =  mc.get( 'foo' )
print  ret

Ps：debug = True 表示运行出现错误时，现实错误信息，上线后移除该参数。数据库

二、天生支持集群

python-memcached模块原生支持集群操做，其原理是在内存维护一个主机列表，且集群中主机的权重值和主机在列表中重复出现的次数成正比

1
2
3
4
5
6
7
      主机    权重
     1.1 . 1.1    1
     1.1 . 1.2    2
     1.1 . 1.3    1
 
那么在内存中主机列表为：
     host_list  =  [ "1.1.1.1" ,  "1.1.1.2" ,  "1.1.1.2" ,  "1.1.1.3" , ]

若是用户根据若是要在内存中建立一个键值对（如：k1 = "v1"），那么要执行一下步骤：

      • 根据算法将 k1 转换成一个数字
      • 将数字和主机列表长度求余数，获得一个值 N（ 0 <= N < 列表长度 ）
      • 在主机列表中根据 第2步获得的值为索引获取主机，例如：host_list[N]
      • 链接 将第3步中获取的主机，将 k1 = "v1" 放置在该服务器的内存中

代码实现以下：

1
2
3
mc  =  memcache.Client([( '1.1.1.1:12000' ,  1 ), ( '1.1.1.2:12000' ,  2 ), ( '1.1.1.3:12000' ,  1 )], debug = True )
 
mc. set ( 'k1' ,  'v1' )

三、add
添加一条键值对，若是已经存在的 key，重复执行add操做异常

1
2
3
4
5
6
7
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import  memcache
 
mc  =  memcache.Client([ '10.211.55.4:12000' ], debug = True )
mc.add( 'k1' ,  'v1' )
# mc.add('k1', 'v2') # 报错，对已经存在的key重复添加，失败！！！

四、replace
replace 修改某个key的值，若是key不存在，则异常

1
2
3
4
5
6
7
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import  memcache
 
mc  =  memcache.Client([ '10.211.55.4:12000' ], debug = True )
# 若是memcache中存在kkkk，则替换成功，不然一场
mc.replace( 'kkkk' , '999' )

五、set 和 set_multi

set            设置一个键值对，若是key不存在，则建立，若是key存在，则修改
set_multi   设置多个键值对，若是key不存在，则建立，若是key存在，则修改

1
2
3
4
5
6
7
8
9
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import  memcache
 
mc  =  memcache.Client([ '10.211.55.4:12000' ], debug = True )
 
mc. set ( 'key0' ,  'wupeiqi' )
 
mc.set_multi({ 'key1' :  'val1' ,  'key2' :  'val2' })

六、delete 和 delete_multi

delete             在Memcached中删除指定的一个键值对
delete_multi    在Memcached中删除指定的多个键值对

1
2
3
4
5
6
7
8
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import  memcache
 
mc  =  memcache.Client([ '10.211.55.4:12000' ], debug = True )
 
mc.delete( 'key0' )
mc.delete_multi([ 'key1' ,  'key2' ])

七、get 和 get_multi

get            获取一个键值对
get_multi   获取多一个键值对

1
2
3
4
5
6
7
8
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import  memcache
 
mc  =  memcache.Client([ '10.211.55.4:12000' ], debug = True )
 
val  =  mc.get( 'key0' )
item_dict  =  mc.get_multi([ "key1" ,  "key2" ,  "key3" ])

八、append 和 prepend

append    修改指定key的值，在该值 后面 追加内容
prepend   修改指定key的值，在该值 前面 插入内容

1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import  memcache
 
mc  =  memcache.Client([ '10.211.55.4:12000' ], debug = True )
# k1 = "v1"
 
mc.append( 'k1' ,  'after' )
# k1 = "v1after"
 
mc.prepend( 'k1' ,  'before' )
# k1 = "beforev1after"

九、decr 和 incr　　

incr  自增，将Memcached中的某一个值增长 N （ N默认为1 ）
decr 自减，将Memcached中的某一个值减小 N （ N默认为1 ）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import  memcache
 
mc  =  memcache.Client([ '10.211.55.4:12000' ], debug = True )
mc. set ( 'k1' ,  '777' )
 
mc.incr( 'k1' )
# k1 = 778
 
mc.incr( 'k1' ,  10 )
# k1 = 788
 
mc.decr( 'k1' )
# k1 = 787
 
mc.decr( 'k1' ,  10 )
# k1 = 777

十、gets 和 cas

如商城商品剩余个数，假设改值保存在memcache中，product_count = 900
A用户刷新页面从memcache中读取到product_count = 900
B用户刷新页面从memcache中读取到product_count = 900

若是A、B用户均购买商品

A用户修改商品剩余个数 product_count＝899
B用户修改商品剩余个数 product_count＝899

如此一来缓存内的数据便不在正确，两个用户购买商品后，商品剩余仍是 899
若是使用python的set和get来操做以上过程，那么程序就会如上述所示状况！

若是想要避免此状况的发生，只要使用 gets 和 cas 便可，如：

1
2
3
4
5
6
7
8
9
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import  memcache
mc  =  memcache.Client([ '10.211.55.4:12000' ], debug = True , cache_cas = True )
 
v  =  mc.gets( 'product_count' )
# ...
# 若是有人在gets以后和cas以前修改了product_count，那么，下面的设置将会执行失败，剖出异常，从而避免非正常数据的产生
mc.cas( 'product_count' ,  "899" )

Ps：本质上每次执行gets时，会从memcache中获取一个自增的数字，经过cas去修改gets的值时，会携带以前获取的自增值和memcache中的自增值进行比较，若是相等，则能够提交，若是不想等，那表示在gets和cas执行之间，又有其余人执行了gets（获取了缓冲的指定值）， 如此一来有可能出现非正常数据，则不容许修改。

 

Redis

redis是一个key-value存储系统。和Memcached相似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操做，并且这些操做都是原子性的。在此基础上，redis支持各类不一样方式的排序。与memcached同样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操做写入追加的记录文件，而且在此基础上实现了master-slave(主从)同步。

1. 使用Redis有哪些好处？

(1) 速度快，由于数据存在内存中，相似于HashMap，HashMap的优点就是查找和操做的时间复杂度都是O(1)

(2) 支持丰富数据类型，支持string，list，set，sorted set，hash

(3) 支持事务，操做都是原子性，所谓的原子性就是对数据的更改要么所有执行，要么所有不执行

(4) 丰富的特性：可用于缓存，消息，按key设置过时时间，过时后将会自动删除


2. redis相比memcached有哪些优点？

(1) memcached全部的值均是简单的字符串，redis做为其替代者，支持更为丰富的数据类型

(2) redis的速度比memcached快不少

(3) redis能够持久化其数据


3. redis常见性能问题和解决方案：

(1) Master最好不要作任何持久化工做，如RDB内存快照和AOF日志文件

(2) 若是数据比较重要，某个Slave开启AOF备份数据，策略设置为每秒同步一次

(3) 为了主从复制的速度和链接的稳定性，Master和Slave最好在同一个局域网内

(4) 尽可能避免在压力很大的主库上增长从库

(5) 主从复制不要用图状结构，用单向链表结构更为稳定，即：Master <- Slave1 <- Slave2 <- Slave3...

这样的结构方便解决单点故障问题，实现Slave对Master的替换。若是Master挂了，能够马上启用Slave1作Master，其余不变。



 

4. MySQL里有2000w数据，redis中只存20w的数据，如何保证redis中的数据都是热点数据

 相关知识：redis 内存数据集大小上升到必定大小的时候，就会施行数据淘汰策略。redis 提供 6种数据淘汰策略：

voltile-lru：从已设置过时时间的数据集（server.db[i].expires）中挑选最近最少使用的数据淘汰

volatile-ttl：从已设置过时时间的数据集（server.db[i].expires）中挑选将要过时的数据淘汰

volatile-random：从已设置过时时间的数据集（server.db[i].expires）中任意选择数据淘汰

allkeys-lru：从数据集（server.db[i].dict）中挑选最近最少使用的数据淘汰

allkeys-random：从数据集（server.db[i].dict）中任意选择数据淘汰

no-enviction（驱逐）：禁止驱逐数据

 

5. Memcache与Redis的区别都有哪些？

1)、存储方式

Memecache把数据所有存在内存之中，断电后会挂掉，数据不能超过内存大小。

Redis有部份存在硬盘上，这样能保证数据的持久性。

2)、数据支持类型

Memcache对数据类型支持相对简单。

Redis有复杂的数据类型。


3），value大小

redis最大能够达到1GB，而memcache只有1MB



6. Redis 常见的性能问题都有哪些？如何解决？

 

1).Master写内存快照，save命令调度rdbSave函数，会阻塞主线程的工做，当快照比较大时对性能影响是很是大的，会间断性暂停服务，因此Master最好不要写内存快照。


2).Master AOF持久化，若是不重写AOF文件，这个持久化方式对性能的影响是最小的，可是AOF文件会不断增大，AOF文件过大会影响Master重启的恢复速度。Master最好不要作任何持久化工做，包括内存快照和AOF日志文件，特别是不要启用内存快照作持久化,若是数据比较关键，某个Slave开启AOF备份数据，策略为每秒同步一次。

 
3).Master调用BGREWRITEAOF重写AOF文件，AOF在重写的时候会占大量的CPU和内存资源，致使服务load太高，出现短暂服务暂停现象。

4). Redis主从复制的性能问题，为了主从复制的速度和链接的稳定性，Slave和Master最好在同一个局域网内




7, redis 最适合的场景


Redis最适合全部数据in-momory的场景，虽然Redis也提供持久化功能，但实际更多的是一个disk-backed的功能，跟传统意义上的持久化有比较大的差异，那么可能你们就会有疑问，彷佛Redis更像一个增强版的Memcached，那么什么时候使用Memcached,什么时候使用Redis呢?

       若是简单地比较Redis与Memcached的区别，大多数都会获得如下观点：
、Redis不只仅支持简单的k/v类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
、Redis支持数据的备份，即master-slave模式的数据备份。
、Redis支持数据的持久化，能够将内存中的数据保持在磁盘中，重启的时候能够再次加载进行使用。

（1）、会话缓存（Session Cache）

最经常使用的一种使用Redis的情景是会话缓存（session cache）。用Redis缓存会话比其余存储（如Memcached）的优点在于：Redis提供持久化。当维护一个不是严格要求一致性的缓存时，若是用户的购物车信息所有丢失，大部分人都会不高兴的，如今，他们还会这样吗？

幸运的是，随着 Redis 这些年的改进，很容易找到怎么恰当的使用Redis来缓存会话的文档。甚至广为人知的商业平台Magento也提供Redis的插件。

（2）、全页缓存（FPC）

除基本的会话token以外，Redis还提供很简便的FPC平台。回到一致性问题，即便重启了Redis实例，由于有磁盘的持久化，用户也不会看到页面加载速度的降低，这是一个极大改进，相似PHP本地FPC。

再次以Magento为例，Magento提供一个插件来使用Redis做为全页缓存后端。

此外，对WordPress的用户来讲，Pantheon有一个很是好的插件  wp-redis，这个插件能帮助你以最快速度加载你曾浏览过的页面。

（3）、队列

Reids在内存存储引擎领域的一大优势是提供 list 和 set 操做，这使得Redis能做为一个很好的消息队列平台来使用。Redis做为队列使用的操做，就相似于本地程序语言（如Python）对 list 的 push/pop 操做。

若是你快速的在Google中搜索“Redis queues”，你立刻就能找到大量的开源项目，这些项目的目的就是利用Redis建立很是好的后端工具，以知足各类队列需求。例如，Celery有一个后台就是使用Redis做为broker，你能够从这里去查看。

（4），排行榜/计数器

Redis在内存中对数字进行递增或递减的操做实现的很是好。集合（Set）和有序集合（Sorted Set）也使得咱们在执行这些操做的时候变的很是简单，Redis只是正好提供了这两种数据结构。因此，咱们要从排序集合中获取到排名最靠前的10个用户–咱们称之为“user_scores”，咱们只须要像下面同样执行便可：

固然，这是假定你是根据你用户的分数作递增的排序。若是你想返回用户及用户的分数，你须要这样执行：

ZRANGE user_scores 0 10 WITHSCORES

Agora Games就是一个很好的例子，用Ruby实现的，它的排行榜就是使用Redis来存储数据的，你能够在这里看到。

（5）、发布/订阅

最后（但确定不是最不重要的）是Redis的发布/订阅功能。发布/订阅的使用场景确实很是多。我已看见人们在社交网络链接中使用，还可做为基于发布/订阅的脚本触发器，甚至用Redis的发布/订阅功能来创建聊天系统！（不，这是真的，你能够去核实）。

Redis提供的全部特性中，我感受这个是喜欢的人最少的一个，虽然它为用户提供若是此多功能。
Redis概述

Redis安装

1
2
3
4
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

启动服务端

1
src / redis - server

根据需求修改redis.conf，个人放在/etc/redis.conf。可经过命令find / -name redis.conf 查找

因为个人linux一开始报错，根据提示我修改了配置protected-mode no便可使用

import redis

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

r = redis.Redis(connection_pool=pool)
r.set('foo', 'qwertyuiop')
print(r.get('foo'))
# b'qwertyuiop'
使用小测

 

启动客户端

1
2
3
4
5
src / redis - cli
redis>  set  foo bar
OK
redis> get foo
"bar"

补充：redis后台运行没法运行reids-cli，修改redis.conf文件将daemonize改为yes(也就是改为后台进程)，而后重启redis服务。

https://zhidao.baidu.com/question/1436485675118684499.html

Python操做Redis

1
2
3
4
5
6
7
sudo pip install redis
or
sudo easy_install redis
or
源码安装
 
详见：https: / / github.com / WoLpH / redis - py

API使用

redis-py 的API的使用能够分类为：

      • 链接方式
      • 链接池
      • 操做
        • String 操做
        • Hash 操做
        • List 操做
        • Set 操做
        • Sort Set 操做
      • 管道
      • 发布订阅

 

一、操做模式

redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。

1
2
3
4
5
6
7
8
#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
import  redis
 
r  =  redis.Redis(host = '10.211.55.4' , port = 6379 )
r. set ( 'foo' ,  'Bar' )
print  r.get( 'foo' )

二、链接池

redis-py使用connection pool来管理对一个redis server的全部链接，避免每次创建、释放链接的开销。默认，每一个Redis实例都会维护一个本身的链接池。能够直接创建一个链接池，而后做为参数Redis，这样就能够实现多个Redis实例共享一个链接池。

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
import  redis
 
pool  =  redis.ConnectionPool(host = '10.211.55.4' , port = 6379 )
 
r  =  redis.Redis(connection_pool = pool)
r. set ( 'foo' ,  'Bar' )
print  r.get( 'foo' )

三、操做

String

String操做，redis中的String在在内存中按照一个name对应一个value来存储。如图：

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

1
2
3
4
5
6
在Redis中设置值，默认，不存在则建立，存在则修改
参数：
      ex，过时时间（秒）
      px，过时时间（毫秒）
      nx，若是设置为True，则只有name不存在时，当前set操做才执行
      xx，若是设置为True，则只有name存在时，岗前set操做才执行

setnx(name, value)

1
设置值，只有name不存在时，执行设置操做（添加）

setex(name, value, time)

1
2
3
# 设置值
# 参数：
     # time，过时时间（数字秒 或 timedelta对象）

psetex(name, time_ms, value)

1
2
3
# 设置值
# 参数：
     # time_ms，过时时间（数字毫秒 或 timedelta对象）

mset(*args, **kwargs)

1
2
3
4
5
批量设置值
如：
     mset(k1= 'v1' , k2= 'v2' )
     或
     mget({ 'k1' :  'v1' ,  'k2' :  'v2' })

get(name)

1
获取值

mget(keys, *args)

1
2
3
4
5
批量获取
如：
     mget( 'ylr' ,  'wupeiqi' )
     或
     r.mget([ 'ylr' ,  'wupeiqi' ])

getset(name, value)

1
设置新值并获取原来的值

getrange(key, start, end)

1
2
3
4
5
6
# 获取子序列（根据字节获取，非字符）
# 参数：
     # name，Redis 的 name
     # start，起始位置（字节）
     # end，结束位置（字节）
# 如： "武沛齐" ，0-3表示 "武"

setrange(name, offset, value)

1
2
3
4
# 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加）
# 参数：
     # offset，字符串的索引，字节（一个汉字三个字节）
     # value，要设置的值

setbit(name, offset, value)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 对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"
 
# 扩展，转换二进制表示：
 
     # source = "武沛齐"
     source  =  "foo"
 
     for  i  in  source:
         num  =  ord (i)
         print  bin (num).replace( 'b' ,'')
 
     特别的，若是source是汉字  "武沛齐" 怎么办？
     答：对于utf - 8 ，每个汉字占  3  个字节，那么  "武沛齐"  则有  9 个字节
        对于汉字， for 循环时候会按照 字节 迭代，那么在迭代时，将每个字节转换 十进制数，而后再将十进制数转换成二进制
         11100110  10101101  10100110  11100110  10110010  10011011  11101001  10111101  10010000
         - - - - - - - - - - - - - - - - - - - - - - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                     武                         沛                           齐

getbit(name, offset)

1
# 获取name对应的值的二进制表示中的某位的值 （0或1）

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

1
2
3
4
5
# 获取name对应的值的二进制表示中 1 的个数
# 参数：
     # key，Redis的name
     # start，位起始位置
     # end，位结束位置

bitop(operation, dest, *keys)

1
2
3
4
5
6
7
8
9
10
# 获取多个值，并将值作位运算，将最后的结果保存至新的name对应的值
 
# 参数：
     # operation,AND（并） 、 OR（或） 、 NOT（非） 、 XOR（异或）
     # dest, 新的Redis的name
     # *keys,要查找的Redis的name
 
# 如：
     bitop( "AND" ,  'new_name' ,  'n1' ,  'n2' ,  'n3' )
     # 获取Redis中n1,n2,n3对应的值，而后讲全部的值作位运算（求并集），而后将结果保存 new_name 对应的值中

strlen(name)

1
# 返回name对应值的字节长度（一个汉字3个字节）

incr(self, name, amount=1)

1
2
3
4
5
6
7
# 自增 name对应的值，当name不存在时，则建立name＝amount，不然，则自增。
 
# 参数：
     # name,Redis的name
     # amount,自增数（必须是整数）
 
# 注：同incrby

incrbyfloat(self, name, amount=1.0)

1
2
3
4
5
# 自增 name对应的值，当name不存在时，则建立name＝amount，不然，则自增。
 
# 参数：
     # name,Redis的name
     # amount,自增数（浮点型）

decr(self, name, amount=1)

1
2
3
4
5
# 自减 name对应的值，当name不存在时，则建立name＝amount，不然，则自减。
 
# 参数：
     # name,Redis的name
     # amount,自减数（整数）

append(key, value)

1
2
3
4
5
# 在redis name对应的值后面追加内容
 
# 参数：
     key, redis的name
     value, 要追加的字符串 
import redis

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

r = redis.Redis(connection_pool=pool)
# r.set('foo', 'qwertyuiop')
# print(r.get('foo'))

# b'qwertyuiop'
r.append("foo","hahaha")
res = r.get("foo")
print(res)
# b'qwertyuiophahaha'
append

 

Hash

Hash操做，redis中Hash在内存中的存储格式以下图：

hset(name, key, value)

1
2
3
4
5
6
7
8
9
# name对应的hash中设置一个键值对（不存在，则建立；不然，修改）
 
# 参数：
     # name，redis的name
     # key，name对应的hash中的key
     # value，name对应的hash中的value
 
# 注：
     # hsetnx(name, key, value),当name对应的hash中不存在当前key时则建立（至关于添加）

hmset(name, mapping)

1
2
3
4
5
6
7
8
# 在name对应的hash中批量设置键值对
 
# 参数：
     # name，redis的name
     # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
 
# 如：
     # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

hget(name,key)

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

hmget(name, keys, *args)

1
2
3
4
5
6
7
8
9
10
11
# 在name对应的hash中获取多个key的值
 
# 参数：
     # name，reids对应的name
     # keys，要获取key集合，如：['k1', 'k2', 'k3']
     # *args，要获取的key，如：k1,k2,k3
 
# 如：
     # r.mget('xx', ['k1', 'k2'])
     # 或
     # print r.hmget('xx', 'k1', 'k2')

hgetall(name)

1
获取name对应 hash 的全部键值

hlen(name)

1
# 获取name对应的hash中键值对的个数

hkeys(name)

1
# 获取name对应的hash中全部的key的值

hvals(name)

1
# 获取name对应的hash中全部的value的值

hexists(name, key)

1
# 检查name对应的hash是否存在当前传入的key

hdel(name,*keys)

1
# 将name对应的hash中指定key的键值对删除

hincrby(name, key, amount=1)

1
2
3
4
5
# 自增name对应的hash中的指定key的值，不存在则建立key=amount
# 参数：
     # name，redis中的name
     # key， hash对应的key
     # amount，自增数（整数）

hincrbyfloat(name, key, amount=1.0)

1
2
3
4
5
6
7
8
# 自增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)

1
2
3
4
5
6
7
8
9
10
11
12
13
# 增量式迭代获取，对于数据大的数据很是有用，hscan能够实现分片的获取数据，并不是一次性将数据所有获取完，从而放置内存被撑爆
 
# 参数：
     # name，redis的name
     # cursor，游标（基于游标分批取获取数据）
     # match，匹配指定key，默认None 表示全部的key
     # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
 
# 如：
     # 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
     # 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
     # ...
     # 直到返回值cursor的值为0时，表示数据已经经过分片获取完毕

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

1
2
3
4
5
6
7
8
9
# 利用yield封装hscan建立生成器，实现分批去redis中获取数据
 
# 参数：
     # match，匹配指定key，默认None 表示全部的key
     # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
 
# 如：
     # for item in r.hscan_iter('xx'):
     #     print item

　　

List

List操做，redis中的List在在内存中按照一个name对应一个List来存储。如图：

lpush(name,values)

1
2
3
4
5
6
7
8
# 在name对应的list中添加元素，每一个新的元素都添加到列表的最左边
 
# 如：
     # r.lpush('oo', 11,22,33)
     # 保存顺序为: 33,22,11
 
# 扩展：
     # rpush(name, values) 表示从右向左操做

lpushx(name,value)

1
2
3
4
# 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
 
# 更多：
     # rpushx(name, value) 表示从右向左操做

llen(name)

1
# name对应的list元素的个数

linsert(name, where, refvalue, value))

1
2
3
4
5
6
7
# 在name对应的列表的某一个值前或后插入一个新值
 
# 参数：
     # name，redis的name
     # where，BEFORE或AFTER
     # refvalue，标杆值，即：在它先后插入数据
     # value，要插入的数据

r.lset(name, index, value)

1
2
3
4
5
6
# 对name对应的list中的某一个索引位置从新赋值
 
# 参数：
     # name，redis的name
     # index，list的索引位置
     # value，要设置的值

r.lrem(name, value, num)

1
2
3
4
5
6
7
8
# 在name对应的list中删除指定的值
 
# 参数：
     # name，redis的name
     # value，要删除的值
     # num，  num=0，删除列表中全部的指定值；
            # num=2,从前到后，删除2个；
            # num=-2,从后向前，删除2个

lpop(name)

1
2
3
4
# 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
 
# 更多：
     # rpop(name) 表示从右向左操做

lindex(name, index)

1
在name对应的列表中根据索引获取列表元素

lrange(name, start, end)

1
2
3
4
5
# 在name对应的列表分片获取数据
# 参数：
     # name，redis的name
     # start，索引的起始位置
     # end，索引结束位置

ltrim(name, start, end)

1
2
3
4
5
# 在name对应的列表中移除没有在start-end索引之间的值
# 参数：
     # name，redis的name
     # start，索引的起始位置
     # end，索引结束位置

rpoplpush(src, dst)

1
2
3
4
# 从一个列表取出最右边的元素，同时将其添加至另外一个列表的最左边
# 参数：
     # src，要取数据的列表的name
     # dst，要添加数据的列表的name

blpop(keys, timeout)

1
2
3
4
5
6
7
8
# 将多个列表排列，按照从左到右去pop对应列表的元素
 
# 参数：
     # keys，redis的name的集合
     # timeout，超时时间，当元素全部列表的元素获取完以后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
 
# 更多：
     # r.brpop(keys, timeout)，从右向左获取数据

brpoplpush(src, dst, timeout=0)

1
2
3
4
5
6
# 从一个列表的右侧移除一个元素并将其添加到另外一个列表的左侧
 
# 参数：
     # src，取出并要移除元素的列表对应的name
     # dst，要插入元素的列表对应的name
     # timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞

自定义增量迭代

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 因为redis类库中没有提供对列表元素的增量迭代，若是想要循环name对应的列表的全部元素，那么就须要：
     # 一、获取name对应的全部列表
     # 二、循环列表
# 可是，若是列表很是大，那么就有可能在第一步时就将程序的内容撑爆，全部有必要自定义一个增量迭代的功能：
 
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操做，Set集合就是不容许重复的列表

 

sadd(name,values)

1
# name对应的集合中添加元素

scard(name)

1
获取name对应的集合中元素个数

sdiff(keys, *args)

1
在第一个name对应的集合中且不在其余name对应的集合的元素集合

sdiffstore(dest, keys, *args)

1
# 获取第一个name对应的集合中且不在其余name对应的集合，再将其新加入到dest对应的集合中

sinter(keys, *args)

1
# 获取多一个name对应集合的并集

sinterstore(dest, keys, *args)

1
# 获取多一个name对应集合的并集，再讲其加入到dest对应的集合中

sismember(name, value)

1
# 检查value是不是name对应的集合的成员

smembers(name)

1
# 获取name对应的集合的全部成员

smove(src, dst, value)

1
# 将某个成员从一个集合中移动到另一个集合

spop(name)

1
# 从集合的右侧（尾部）移除一个成员，并将其返回

srandmember(name, numbers)

1
# 从name对应的集合中随机获取 numbers 个元素

srem(name, values)

1
# 在name对应的集合中删除某些值

sunion(keys, *args)

1
# 获取多一个name对应的集合的并集

sunionstore(dest,keys, *args)

 

补充：

sscan(name, cursor=0, match=None, count=None)：匹配name对应的集合中的value

sscan_iter(name, match=None, count=None)：为迭代匹配name对应的集合中的value  # 对应smembers



同理，其余数据类型也有_iter方法

 

sort set

有序集合，在集合的基础上，为每元素排序；元素的排序须要根据另一个值来进行比较，因此，对于有序集合，每个元素有两个值，即：值和分数，分数专门用来作排序。

zadd(name, *args, **kwargs)

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

zcard(name)

1
# 获取name对应的有序集合元素的数量

zcount(name, min, max)

1
# 获取name对应的有序集合中分数 在 [min,max] 之间的个数

zincrby(name, value, amount)

1
# 自增name对应的有序集合的 name 对应的分数

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 按照索引范围获取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)

zrank(name, value)

1
2
3
4
# 获取某个值在 name对应的有序集合中的排行（从 0 开始）
 
# 更多：
     # zrevrank(name, value)，从大到小排序

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 当有序集合的全部成员都具备相同的分值时，有序集合的元素会根据成员的 值 （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)

1
2
3
# 删除name对应的有序集合中值是values的成员
 
# 如：zrem('zz', ['s1', 's2'])

zremrangebyrank(name, min, max)

1
# 根据排行范围删除

zremrangebyscore(name, min, max)

1
# 根据分数范围删除

zremrangebylex(name, min, max)

1
# 根据值返回删除

zscore(name, value)

1
# 获取name对应有序集合中 value 对应的分数

zinterstore(dest, keys, aggregate=None)

1
2
# 获取两个有序集合的交集，若是遇到相同值不一样分数，则按照aggregate进行操做
# aggregate的值为:  SUM  MIN  MAX

zunionstore(dest, keys, aggregate=None)

1
2
# 获取两个有序集合的并集，若是遇到相同值不一样分数，则按照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)

1
# 同字符串类似，相较于字符串新增score_cast_func，用来对分数进行操做

　　

其余经常使用操做

delete(*names)

1
# 根据删除redis中的任意数据类型

exists(name)

1
# 检测redis的name是否存在

keys(pattern='*')

1
2
3
4
5
6
7
# 根据模型获取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)

ttl命令在键不存在或被删除以后，会返回-2，在没有为键设置生存时间（即永久存在，建一个键以后的默认状况）时返回的是-1。你们能够亲自操做一把。

若是想要把一个设置过过时时间的键取消过时时间设置，则须要使用persist命令。

除了使用persist命令外，使用set、getset命令为键赋值，也会同时消除键的生存时间，若是须要能够从新使用expire命令为键设置生存时间。而其余对键的操做命令（如incr、lpush、hset、zrem）都不会影响键的生存时间。

expire命令的单位是秒，并且这个参数必须为整数，若是须要更精准的时间的话，须要使用pexpire命令设置，其单位为毫秒，同理也须要用pttl命令来看键的剩余毫秒数。固然使用expire命令设置的过时时间也是能够用pttl看键的剩余毫秒数的。

1
# 为某个redis的某个name设置超时时间，在redis-cli上命令是ttl name

rename(src, dst)

1
# 对redis的name重命名为

move(name, db))

1
# 将redis的某个值移动到指定的db下

randomkey()

1
# 随机获取一个redis的name（不删除）

type(name)

1
# 获取name对应值的类型

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

1
# 同字符串操做，用于增量迭代获取key

　

补充：

 r.flushdb()        #清空r中的全部数据

r.dbsize()         #当前数据库包含多少条数据

 r.save()               #执行“检查点”操做，将数据写回磁盘。保存时阻塞

 

四、管道

redis-py默认在执行每次请求都会建立（链接池申请链接）和断开（归还链接池）一次链接操做，若是想要在一次请求中指定多个命令，则可使用pipline实现一次请求指定多个命令，而且默认状况下一次pipline 是原子性操做。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
import  redis
 
pool  =  redis.ConnectionPool(host = '10.211.55.4' , port = 6379 )
 
r  =  redis.Redis(connection_pool = pool)
 
# pipe = r.pipeline(transaction=False)
pipe  =  r.pipeline(transaction = True )
pipe.multi()
pipe. set ( 'name' ,  'alex' )
pipe. set ( 'role' ,  'sb' )
 
pipe.execute() 
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import redis

conn = redis.Redis(host='192.168.1.41',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)
    if count > 0:  # 有库存
        pipe.set('count', count - 1)

    # 执行，把全部命令一次性推送过去
    pipe.execute()

实现计数器
实现计数器

五、发布订阅

发布者：服务器

订阅者：Dashboad和数据处理

Demo以下：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import redis


class RedisHelper:

    def __init__(self):
        self.__conn = redis.Redis(host='10.211.55.4')
        self.chan_sub = 'fm104.5'
        self.chan_pub = 'fm104.5'

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg)
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()
        pub.subscribe(self.chan_sub)
        pub.parse_response()
        return pub
RedisHelper

订阅者：

1
2
3
4
5
6
7
8
9
10
11
#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
from  monitor.RedisHelper  import  RedisHelper
 
obj  =  RedisHelper()
redis_sub  =  obj.subscribe()
 
while  True :
     msg =  redis_sub.parse_response()
     print  msg

发布者：

1
2
3
4
5
6
7
#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
from  monitor.RedisHelper  import  RedisHelper
 
obj  =  RedisHelper()
obj.public( 'hello' )

实测：

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import redis


class RedisHelper:

    def __init__(self):
        self.__conn = redis.Redis(host='1.1.1.39')
        self.chan_sub = 'fm104.5'
        self.chan_pub = 'fm104.5'

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg)
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()
        pub.subscribe(self.chan_sub)
        pub.parse_response()
        return pub
redishelper.py 
from redishelper import RedisHelper

obj = RedisHelper()
obj.public("hello")
publisher.py 
# -*- coding:utf-8 -*-

from redishelper import RedisHelper

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

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

测试有效。

6. sentinel

redis重的sentinel主要用于在redis主从复制中，若是master顾上，则自动将slave替换成master

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
from  redis.sentinel  import  Sentinel
 
# 链接哨兵服务器(主机名也能够用域名)
sentinel  =  Sentinel([( '10.211.55.20' ,  26379 ),
                      ( '10.211.55.20' ,  26380 ),
                      ],
                     socket_timeout = 0.5 )
 
# # 获取主服务器地址
# master = sentinel.discover_master('mymaster')
# print(master)
#
# # # 获取从服务器地址
# slave = sentinel.discover_slaves('mymaster')
# print(slave)
#
#
# # # 获取主服务器进行写入
# master = sentinel.master_for('mymaster')
# master.set('foo', 'bar')
 
 
 
# # # # 获取从服务器进行读取（默认是round-roubin）
# slave = sentinel.slave_for('mymaster', password='redis_auth_pass')
# r_ret = slave.get('foo')
# print(r_ret)

　　

7.缓存

有时候会把一些对CPU或IO资源消耗比较大的操做结果缓存起来，并设置必定时间的自动过时。好比咱们设定一个微博外链的最热站点缓存放于新浪微博的首页，这样咱们不可能每次访问都从新计算最热的外链站点，因此咱们能够设定两小时更新一次。每次访问是判断这个键有没有，若是存在则直接返回，若是没有则经过计算把内容存入键中，并设定两小时的过时时间。

然而在不少场合这种方法会很恐怖，当服务器内存有限的时候，大量使用缓存切设置生存时间过长就会致使redis占用太多内存，而redis有时候会把系统内存都吃掉，致使系统崩溃。可是设置时间太短又会致使缓存的命中过低。

因此咱们最好的办法是设定缓存的淘汰规则。这种方式比较适用于将redis用做缓存系统的时候比较好。

具体就是：修改配置文件中的maxmemory参数，限制redis的最大内存，当超出后会按照maxmemory-policy参数指定的策略删除不须要的键，直到redis占用的内存小于设定值。

规则

说明

volatile-lru

 使用LRU算法删除一个键（只对设置了生存时间的键）

allkeys-lru

 使用LRU算法删除一个键

volatile-random

 随机删除一个键（只对设置了生存时间的键）

allkeys- random

 随机删除一个键

volatile-ttl

 删除生存时间最近的一个键

noeviction

 不删除键，只返回错误

其中的LRU算法便是【最近最少使用】。

这里提一句，实际上redis根本就不会准确的将整个数据库中最久未被使用的键删除，而是每次从数据库中随机取3个键并删除这3个键里最久未被使用的键。上面提到的全部的随机的操做实际上都是这样的，这个3能够用过redis的配置文件中的maxmemeory-samples参数配置。

 

8.访问限制

有时候咱们会有一个需求是须要限制一个用户对一个资源的访问频率，咱们假定一个用户（用IP做为判断）每分钟对一个资源访问次数不能超过10次。

咱们可使用一个键，每次用户访问则把值加1，当值加到10的时候，咱们设定键的过时时间为60秒，而且禁止访问。这时候下次访问发现值为10，则不让访问了，而后60秒后键被删除，这时候再次建立键。这样就能够解决，可是其实这样时间并不精准，问题仍是挺大的。

咱们还有一个方案：使用队列。前面的章节也说到了，使用列表类型能够用做队列。

咱们设定一个队列rate.limiting.192.168.1.1（假定是这个IP），咱们把每次的访问时间都添加到队列中，当队列长度达到10之后，判断当前时间与队列第一个值的时间差是否小于60，若是小于60则说明60秒内访问次数超过10次，不容许访问；不然说明能够访问，则把队列头的值删除，队列尾增长当前访问时间。

这种方法能够比较精准的实现访问限制，可是当限制的次数比较大时，这种方法占用的存储空间也会比较大。

 

更多参见：https://github.com/andymccurdy/redis-py/

http://doc.redisfans.com/

 

 

 

参考or转发

http://www.cnblogs.com/wupeiqi/articles/5132791.html

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程