python操作memcached

memcache简介

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

安装memecache

1
2
3
4
5
cd /usr/local/src
wget http://memcached.org/latest
tar -zxvf memcached-1.x.x.tar.gz
cd memcached-1.x.x
./configure && make && make test && make install

        启动memcache

1
memcached -d -m 10 -u root -l 127.0.0.1 -p 12000 -c 256 -P /export/servers/memcache/logs/memcache.pid
  • -p 指定端口号（默认11211）
  • -m 指定最大使用内存大小（默认64MB）
  • -t 线程数（默认4）
  • -l 连接的IP地址, 默认是本机
  • -d 以后台守护进程的方式启动
  • -c 最大同时连接数，默认是1024
  • -P 制定memecache的pid文件
  • -h 打印帮助信息

        检查memcache是否启动

Python操作memcache集群

        天生支持集群：

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

主机 权重
1.1.1.1 1
1.1.1.2 2
1.1.1.3 1

        那么在内存中主机列表为：

1
host_list=['1.1.1.1','1.1.1.2','1.1.1.2','1.1.1.3',]

        下面来看一个例子，python操作memcache集群

1
2
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')

        如果用户要在内存中创建一个键值对(如：k1 = “v1”),那么要执行以下步骤：

        根据算法将k1转换成一个数字；

        将数字和主机列表长度求余数，得到一个值N(0 <= N < 列表长度)；

        在主机列表中根据第2步得到的值为索引获取主机，例如：host_list[N];

        连接将第3步中获取的主机，将k1 = ‘v1’放置在该服务器的内存中。

        上面例子我们通过调用memcache模块来实现对memcached进行存取数据，debug=True表示运行中出现错误时，显示错误信息，上线后移除该参数。

Memcache常用命令

  • 存储命令： set/add/replace/append/prepend/cas
  • 获取命令： get/gets
  • 其他命令： delete/stats..

add方法

        添加一条键值对，如果已经存在的key，重复执行add操作会报异常。

1
2
3
4
5
6
7
8
import memcache
mc = memcache.Client(['192.168.48.128:11211'], debug=True)
# mc.set("foo", "bar")
# ret = mc.get("foo")
mc.add('k1','v1')
mc.add('k1','v1')
# print(ret)

replace方法

        replace修改某个key的值，如果key不存在，则异常。

1
2
3
4
5
6
7
8
9
10
import memcache
mc = memcache.Client(['192.168.48.128:11211'], debug=True)
# mc.set("foo", "bar")
# ret = mc.get("foo")
mc.add('k1','v1')
# mc.add('k1','v1')
# print(ret)
mc.replace("k1", "666")
print(mc.get("k1"))

        结果：

1
666

set和set_multi方法

        set ：设置一个键值对，如果key不存在，则创建，如果key存在，则修改；

        set_multi：设置多个键值对，如果key不存在，则创建，如果key存在，则修改。

1
2
3
4
5
import memcache
mc = memcache.Client(['192.168.48.128:11211'], debug=True)
mc.set("k10", "v10")
mc.set_multi({"k11": "v11", "k12": "v12"})

set方法和add方法的区别

1
set = add + replace
  1. memcache::add 方法：add方法用于向memcache服务器添加一个要缓存的数据。

        注意：如果memcache服务器中已经存在要存储的key，此时add方法调用失败。

  1. memcache::set 方法：set方法用于设置一个指定key的缓存内容，set方法是add方法和replace方法的集合体。

        注意：

  • 如果要设置的key不存在时，则set方法与add方法的效果一致；

  • 如果要设置的key已经存在时，则set方法与replace方法效果一样。

  1. mmecache::replace方法：

        replace方法用于替换一个指定key的缓存内容，如果key不存在则返回false

delete和delete_multi方法

        delete：在Memcached中删除指定的一个键值对；

        delete_multi：在Memcached中删除指定的多个键值对。

1
2
3
4
5
6
7
8
import memcache
mc = memcache.Client(['192.168.48.128:11211'], debug=True)
# mc.set("k10", "v10")
# mc.set_multi({"k11": "v11", "k12": "v12"})
#
mc.delete("k10")
mc.delete_multi(["k11", "k12"])

get和get_multi方法

        get : 获取一个键值对；

        get_multi：获取多个键值对。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import memcache
mc = memcache.Client(['192.168.48.128:11211'], debug=True)
mc.set("k10", "v10")
mc.set_multi({"k11": "v11", "k12": "v12"})
#
# mc.delete("k10")
# mc.delete_multi(["k11", "k12"])
val = mc.get('k1')
print(val)
item_dict = mc.get_multi(['k11', 'k12'])
print(item_dict)

append和prepend方法

        append：修改指定key的值，在该值后面追加内容；

        prepend：修改指定key的值，在该值前面插入内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import memcache
 
mc = memcache.Client(['192.168.10.128:12000'], debug=True)
 
mc.append('k1','after')
val1 = mc.get('k1')
print(val1)
 
mc.prepend('k1','brefore')
val2 = mc.get('k1')
print(val2)
``` 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;结果：
```python
v1afterafter
breforev1afterafter

        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
19
20
21
22
23
24
25
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import memcache
 
mc = memcache.Client(['192.168.10.128:12000'], debug=True)
 
mc.set('k1','777')
 
#mc.incr('k1')        #778，默认自增1
 
mc.incr('k1',10)
val1 = mc.get('k1')
print(val1)
 
mc.decr('k1',20)
val2 = mc.get('k1')
print(val2)
``` 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;结果
```python 
787  #自增后的结果
767  #自减后的结果

gets和cas：

        如商城商品剩余个数，假设改值保存在memcache中，product_count =9000

        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(['192.168.10.128:12000'], debug=True)
 
v = mc.gets('product_count')
print(v)

        如果有人在gets之后和cas之前修改了product_count,那么下面的设置将会执行失败，抛出异常，从而避免非正常数据的产出

1
2
3
4
5
6
7
8
9
v1 = mc.cas('product_count',"899")
print(v1)
``` 
&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;结果：
```python
899
True

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