编程►python

python访问memcached

memcached介绍

Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程（daemon ）是用C写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。
memcached在实现分布式群集部署时，memcached服务之间是不能进行通讯的，分布式也是通过客户端的算法把数据保存在不同的memcached中。magent是一款开源的代理服务软件，我们可以通过它来实现缓存数据的同步。magent还可以使用keepalived来实现高可用。

memcached安装

安装

在linux下安装

  • 安装libevent
    Libevent 是一个异步事件处理软件函式库，以 BSD 许可证释出。Memcached 依赖 Libevent，因此必须先安装 Libevent。

    1
    yum install libevent-devel

  • 安装memcached

    1
    2
    3
    4
    5
    6
    cd /usr/local/src
    wget http://memcached.org/latest
    tar zxf memcached-1.5.7.tar.gz
    mv memcached-1.5.7 memcached
    cd memcached/
    ./configure && make && make install

启动

1
memcached -d -u root

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

1
2
3
4
5
6
[root@VM_0_4_centos memcached]# ps aux|grep memcache
root     24421  0.0  0.0 413792  1080 ?        Ssl  07:45   0:00 memcached -d -u root
root     24436  0.0  0.0 112644   964 pts/0    R+   07:45   0:00 grep --color=auto memcache
[root@VM_0_4_centos memcached]# netstat -lntp|grep memcached
tcp        0      0 0.0.0.0:11211           0.0.0.0:*               LISTEN      24421/memcached     
tcp6       0      0 :::11211                :::*                    LISTEN      24421/memcached

python访问memcached

python访问memcached需要安装python-memcached模块。

1
pip install python-memcached

操作实例

1
2
3
4
5
import memcache

mem = memcache.Client(["118.24.18.158:11211"])
mem.set("db", "oracle")
print(mem.get("db"))    #输出结果：oracle

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

1
2
3
4
主机IP        权重
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 = “value1”），那么要执行以下步骤：
根据算法将k1转换成一个数字
将数字和主机列表长度求余数，得到一个值N（0 <= N < 长度）
在主机列表中根据第二步得到的值为索引获取主机，例如: host_list[N]
连接将第三步中获取的主机，将k1 = “value1” 放置在该服务器的内存中
代码如下：

1
2
3
4
5
6
7
#!/usr/bin/env python3
#coding:utf8
import memcache
mc = memcache.Client([('1.1.1.1:11211', 1), ('1.1.1.2:11211', 2),('1.1.1.3:11211',1)])
mc.set('k1','value1')
ret = mc.get('k1')
print (ret)

memcached常用操作

  • set(key, val)
    在memcache中设置key的值为val。若key不存在则创建，否则修改。
  • get(key)
    获取memcache中key对应的值或者None。
  • set_multi(mapping)
    一次设置多个key/value对。以列表方式传入。若key不存在则创建，否则修改。

  • get_multi(keys)
    一次获取多个keys

    1
    2
    3
    4
    mem.set_multi({"db1": "oracle", "db2": "mysql"})
    mem.set("db3", "memcache")
    print(mem.get("db1"))    #输出结果：oracle
    print(mem.get_multi(["db2", "db3"]))    #输出结果：{'db2': 'mysql', 'db3': 'memcache'}

  • add(key, val)
    在memcache中添加新的键值对。若已存在则返回False。

    1
    2
    3
    print(mem.add("db", "memcache"))     #输出结果：True
    print(mem.get("db"))     #输出结果：memcache
    print(mem.add("db", "memcache"))     #输出结果：False

  • replace(key, val)
    修改key的值为val，若不存在则返回False。

    1
    2
    3
    4
    mem.add("db", "memcache")
    print(mem.replace("db", "redis"))    #输出结果：True
    print(mem.get("db"))    #输出结果：redis
    print(mem.replace("db1", "redis"))    #输出结果：False

  • delete(key)
    删除一个指定的key/value对。

  • delete_multi(keys)
    删除多个指定的key/value对。

    1
    2
    3
    4
    mem.set_multi({"db1": "oracle", "db2": "mysql", "db3": "memcache"})
    mem.delete("db1")
    mem.delete_multi(["db2", "db3"])
    print(mem.get_multi(["db1", "db2", "db3"]))    #输出结果：{}

  • append(key, val)
    在指定key对应的value后面追加内容。

  • prepend(key, val)
    在指定key对应的额value前面追加内容。

  • stats
    查看历史操作

    1
    2
    3
    4
    5
    6
    7
    mem.set("db", "oracle")
    print(mem.get("db"))    #输出结果：oracle
    mem.append("db", " or mysql")
    print(mem.get("db"))    #输出结果：oracle or mysql
    mem.prepend("db", "redis or ")
    print(mem.get("db"))    #输出结果：redis or oracle or mysql
    print(mem.stats)    #输出结果：{'set': 1, 'get': 3, 'append': 1, 'prepend': 1}

  • gets和cas
    使用缓存系统共享数据资源就必然绕不开数据争夺和脏数据（数据混乱）的问题。
    假设商城某件商品的剩余个数保存在memcache中，product_count = 900，
    A用户刷新页面从memecache中读取到product_count = 900，
    B用户刷新页面从memecache中读取到product_count = 900，
    A,B用户均购买商品，并修改product_count的值。
    A修改后，product_count = 899；
    B修改后，product_count = 899；
    然而正确数字应该是898，数据就混乱了。
    如果想要避免这种情况的发生，则可以使用gets和cas。

    1
    2
    3
    4
    5
    mem = memcache.Client(["118.24.18.158:11211"])
    mem.set("count", "100")
    print(mem.get("count"))    #输出结果：100
    print(mem.cas("count", "99"))    #输出结果：True
    print(mem.gets("count"))    #输出结果：99

gets和cas一起使用，cas是check and set操作。它仅当当前客户端最后一次取值后，该key对应的值没有被其他客户端修改的情况下，才能够将值写入。

Recommended Posts