Python项目使用memcached缓存

前言
许多Web应用都将数据保存到MySQL这样的关系型数据库管理系统中,应用服务器从中读取数据并在浏览器中显示。 但随着数据量的增大、访问的集中,就会出现数据库的负担加重、数据库响应恶化、 网站显示延迟等不良影响。分布式缓存是优化网站性能的重要手段,大量站点都通过可伸缩的服务器集群提供大规模热点数据缓存服务。通过缓存数据库查询结果,减少数据库访问次数,可以显著提高动态Web应用的速度和可扩展性。业界常用的有redis、memcached等,今天要讲的就是在python项目中如何使用memcached缓存服务。

memcached
memcached是一款开源、高性能、分布式内存对象缓存系统,可应用各种需要缓存的场景,其主要目的是通过降低对Database的访问来加速web应用程序。
memcached本身其实不提供分布式解决方案。在服务端,memcached集群环境实际就是一个个memcached服务器的堆积,环境搭建较为简单;cache的分布式主要是在客户端实现,通过客户端的路由处理来达到分布式解决方案的目的。客户端做路由的原理非常简单,应用服务器在每次存取某key的value时,通过路由算法把key映射到某台memcached服务器nodeA上,因此这个key所有操作都在nodeA上进行。只要服务器还缓存着该数据,就能保证缓存命中。

路由算法
简单路由算法
简单路由算法,使用余数Hash:用缓存数据key的hash值,除以服务器的数目,余数为服务器列表的下表编号。这个算法可以让缓存数据在整个memcached集群中均匀的分布,也能满足大多数的缓存路由需求。
但是,当memcached集群要扩容的时候,就会引发问题。例如:网站需要将3台缓存服务器扩容成4台。在更改服务器列表后,若仍使用余数hash,很容易就计算出,75%的请求不能命中缓存。随着服务器集群规模增大,不能命中的比率就越高。

1%3 = 1 1%4 = 1
2%3 = 2 2%4 = 2
3%3 = 0 3%4 = 3
4%4 = 1 4%4 = 0
#以此类推
1
2
3
4
5
这样扩容操作风险极大,可能给数据库带来很大的瞬时压力,甚至可能导致数据库崩溃。解决这个问题有2个方法:1、在访问低谷进行扩容,在扩容后预热数据;2、使用更优的路由算法。目前使用较多的是一致性Hash算法。

一致性哈希
memcached客户端可采用一致性hash算法作为路由策略,如图,相对于一般hash(如简单取模)的算法,一致性hash算法除了计算key的hash值外,还会计算每个server对应的hash值,然后将这些hash值映射到一个有限的值域上(比如0~2^32)。通过寻找hash值大于hash(key)的最小server作为存储该key数据的目标server。如果找不到,则直接把具有最小hash值的server作为目标server。同时,一定程度上,解决了扩容问题,增加或删除单个节点,对于整个集群来说,不会有大的影响。

虚拟层
一致性hash也不是完美的,在扩容时可能导致负载不均衡的问题。最近版本,增加了虚拟节点的设计,进一步提升了可用性。在扩容时,较为均匀的影响集群中已经存在的服务器,均匀的分摊负载。此处不再详述。

内存管理
存储方式
为了提高性能,memcached中保存的数据都存储在memcached内置的内存存储空间中。由于数据仅存在于内存中,因此重启memcached、重启操作系统会导致全部数据消失。另外,缓存的内容容量达到指定值之后,就基于LRU(Least Recently Used)算法自动删除不使用的缓存。memcached本身是为缓存而设计的服务,因此并没有过多考虑数据的永久性问题。

内存结构
memcached仅支持基础的key-value键值对类型数据存储。在memcached内存结构中有两个非常重要的概念:slab和chunk。
slab是一个内存块,它是memcached一次申请内存的最小单位。在启动memcached的时候一般会使用参数-m指定其可用内存,但是并不是在启动的那一刻所有的内存就全部分配出去了,只有在需要的时候才会去申请,而且每次申请一定是一个slab。Slab的大小固定为1M(1048576 Byte),一个slab由若干个大小相等的chunk组成。每个chunk中都保存了一个item结构体、一对key和value。

虽然在同一个slab中chunk的大小相等的,但是在不同的slab中chunk的大小并不一定相等,在memcached中按照chunk的大小不同,可以把slab分为很多种类(class),默认情况下memcached把slab分为40类(class1~class40),在class 1中,chunk的大小为80字节,由于一个slab的大小是固定的1048576字节(1M),因此在class1中最多可以有13107个chunk(也就是这个slab能存最多13107个小于80字节的key-value数据)。

memcached内存管理采取预分配、分组管理的方式,分组管理就是我们上面提到的slab class,按照chunk的大小slab被分为很多种类。内存预分配过程是怎样的呢?向memcached添加一个item时候,memcached首先会根据item的大小,来选择最合适的slab class:例如item的大小为190字节,默认情况下class 4的chunk大小为160字节显然不合适,class 5的chunk大小为200字节,大于190字节,因此该item将放在class 5中(显然这里会有10字节的浪费是不可避免的),计算好所要放入的chunk之后,memcached会去检查该类大小的chunk还有没有空闲的,如果没有,将会申请1M(1个slab)的空间并划分为该种类chunk。例如我们第一次向memcached中放入一个190字节的item时,memcached会产生一个slab class 2(也叫一个page),并会用去一个chunk,剩余5241个chunk供下次有适合大小item时使用,当我们用完这所有的5242个chunk之后,下次再有一个在160~200字节之间的item添加进来时,memcached会再次产生一个class 5的slab(这样就存在了2个pages)。

注意事项
chunk是在page里面划分的,而page固定为1m,所以chunk最大不能超过1m。
chunk实际占用内存要加48B,因为chunk数据结构本身需要占用48B。
如果用户数据大于1m,则memcached会将其切割,放到多个chunk内。
已分配出去的page不能回收。
对于key-value信息,最好不要超过1m的大小;同时信息长度最好相对是比较均衡稳定的,这样能够保障最大限度的使用内存;同时,memcached采用的LRU清理策略,合理甚至过期时间,提高命中率。
使用场景
key-value能满足需求的前提下,使用memcached分布式集群是较好的选择,搭建与操作使用都比较简单;分布式集群在单点故障时,只影响小部分数据异常,目前还可以通过Magent缓存代理模式,做单点备份,提升高可用;整个缓存都是基于内存的,因此响应时间是很快,不需要额外的序列化、反序列化的程序,但同时由于基于内存,数据没有持久化,集群故障重启数据无法恢复。高版本的memcached已经支持CAS模式的原子操作,可以低成本的解决并发控制问题。

安装启动
$ sudo apt-get install memcached
$ memcached -m 32 -p 11211 -d
# memcached将会以守护程序的形式启动 memcached(-d),为其分配32M内存(-m 32),并指定监听 localhost的11211端口。
1
2
3
python操作memcached
在python中可通过memcache库来操作memcached,这个库使用很简单,声明一个client就可以读写memcached缓存了。

python访问memcached
#!/usr/bin/env python

import memcache

mc = memcache.Client([‘127.0.0.1:12000‘],debug=0)

mc.set("some_key", "Some value")
value = mc.get("some_key")

mc.set("another_key", 3)
mc.delete("another_key")

mc.set("key", "1") # note that the key used for incr/decr must be a string.
mc.incr("key")
mc.decr("key")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
然而,python-memcached默认的路由策略没有使用一致性哈希。

def _get_server(self, key):
if isinstance(key, tuple):
serverhash, key = key
else:
serverhash = serverHashFunction(key)

if not self.buckets:
return None, None

for i in range(Client._SERVER_RETRIES):
server = self.buckets[serverhash % len(self.buckets)]
if server.connect():
# print("(using server %s)" % server,)
return server, key
serverhash = serverHashFunction(str(serverhash) + str(i))
return None, None
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
从源码中可以看到:server = self.buckets[serverhash % len(self.buckets)],只是根据key进行了简单的取模。我们可以通过重写_get_server方法,让python-memcached支持一致性哈希。

import memcache
import types
from hash_ring import HashRing
class MemcacheRing(memcache.Client):
"""Extends python-memcache so it uses consistent hashing to
distribute the keys.
"""
def __init__(self, servers, *k, **kw):
self.hash_ring = HashRing(servers)
memcache.Client.__init__(self, servers, *k, **kw)
self.server_mapping = {}
for server_uri, server_obj in zip(servers, self.servers):
self.server_mapping[server_uri] = server_obj

def _get_server(self, key):
if type(key) == types.TupleType:
return memcache.Client._get_server(key)
for i in range(self._SERVER_RETRIES):
iterator = self.hash_ring.iterate_nodes(key)
for server_uri in iterator:
server_obj = self.server_mapping[server_uri]
if server_obj.connect():
return server_obj, key
return None, None
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
torando项目中使用memcached
这里采用的策略是:1. 应用程序先从cache取数据,没有得到,则从数据库中取数据,成功后,放到缓存中。2. 应用程序从cache中取数据,取到后返回。缓存更新是一个很复杂的问题,一般是先把数据存到数据库中,成功后,再让缓存失效。后面会再写文单独讨论memcached缓存更新的问题。

代码
# coding: utf-8
import sys
import tornado.ioloop
import tornado.web
import logging
import memcache
import json
import urllib

# 初始化memcache client
mc = memcache.Client([‘127.0.0.1:11211‘], debug=0)
mc_prefix = ‘demo‘

class BaseHandler(tornado.web.RequestHandler):
""" 把缓存处理抽象到BaseHandler基类 """
USE_CACHE = False # 控制是否使用缓存

def format_args(self):
arg_list = []
for a in self.request.arguments:
for value in self.request.arguments[a]:
arg_list.append(‘%s=%s‘ % (a, urllib.quote(value.replace(‘ ‘, ‘‘))))

# 根据请求的URL产生key
arg_list.sort()
key = ‘%s?%s‘ % (self.request.path, ‘&‘.join(arg_list)) if arg_list else self.request.path
key = ‘%s_%s‘ % (mc_prefix, key)

# key太长,不进行缓存处理
if len(key) > 250:
logging.error(‘key out of length: %s‘, key)
return None

return key

def get(self, *args, **kwargs):
if self.USE_CACHE:
try:
# 根据请求获取key
self.key = self.format_args()
if self.key:
data = mc.get(self.key) # 若缓存命中,则直接返回数据
if data:
logging.info(‘get data from memecahce‘)
self.finish(data)
return
except Exception, e:
logging.exception(e)

# 若未命中缓存,调用do_get处理请求,获取数据
data = self.do_get()
data_str = json.dumps(data)

# 把成功获取到的数据,放入memcache缓存
if self.USE_CACHE and data and data.get(‘result‘, -1) == 0 and self.key:
try:
mc.set(self.key, data_str, 60)
except Exception, e:
logging.exception(e)

self.finish(data_str)

def do_get(self):
return None

class DemoHandler(BaseHandler):
USE_CACHE = True

def do_get(self):
a = self.get_argument(‘a‘, ‘test‘)
b = self.get_argument(‘b‘, ‘test‘)

# 访问数据库获取数据,此处略去
data = {‘result‘: 0, ‘a‘: a, ‘b‘: b}
return data

def make_app():
return tornado.web.Application([
(r"/", DemoHandler),
])

if __name__ == "__main__":
logging.basicConfig(stream=sys.stdout, level=logging.INFO,
format=‘%(asctime)s %(levelno)s %(message)s‘,
)

app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
测试结果
在浏览器访问http://127.0.0.1:8888/?a=1&b=3,终端打印的log如下:

2017-02-21 22:45:05,987 20 304 GET /?a=1&b=2 (127.0.0.1) 3.11ms
2017-02-21 22:45:07,427 20 get data from memecahce
2017-02-21 22:45:07,427 20 304 GET /?a=1&b=2 (127.0.0.1) 0.71ms
2017-02-21 22:45:10,350 20 200 GET /?a=1&b=3 (127.0.0.1) 0.82ms
2017-02-21 22:45:13,586 20 get data from memecahce
1
2
3
4
5
从日志可以看到,缓存命中的情况。

小结
本文介绍了memcached的路由算法、内存管理、使用场景等基本概念,然后举例说明了在python项目中如何使用memcached缓存。缓存更新的问题还需要进一步分析讨论。

参考
缓存那些事儿
《大型网站技术架构》李智慧
---------------------
作者:dutsoft
来源:CSDN
原文:https://blog.csdn.net/dutsoft/article/details/71101809?utm_source=copy
版权声明:本文为博主原创文章,转载请附上博文链接!

原文地址:https://www.cnblogs.com/ExMan/p/9777927.html

时间: 2024-11-06 21:30:41

Python项目使用memcached缓存的相关文章

第八章 企业项目开发--分布式缓存memcached

注意:本节代码基于<第七章 企业项目开发--本地缓存guava cache> 1.本地缓存的问题 本地缓存速度一开始高于分布式缓存,但是随着其缓存数量的增加,所占内存越来越大,系统运行内存越来越小,最后系统会被拖慢(这一点与第二点联系起来) 本地缓存存于本机,其缓存数量与大小受本机内存大小限制 本地缓存存于本机,其他机器的访问不到这样的缓存 解决方案:分布式缓存 Jboss cache:缓存还存于本机,但是会同步更新到其他机器(解决了第三个问题,解决不了第一和第二个问题),如果缓存机器数量很多

受教了,memcache比较全面点的介绍,受益匪浅,适用memcached的业务场景有哪些?memcached的cache机制是怎样的?在设计应用时,可以通过Memcached缓存那些内容?

基本问题 1.memcached的基本设置 1)启动Memcache的服务器端 # /usr/local/bin/memcached -d -m 10 -u root -l 192.168.0.200 -p 12000 -c 256 -P /tmp/memcached.pid -d选项是启动一个守护进程, -m是分配给Memcache使用的内存数量,单位是MB,我这里是10MB, -u是运行Memcache的用户,我这里是root, -l是监听的服务器IP地址,如果有多个地址的话,我这里指定了服

第九章 企业项目开发--分布式缓存Redis(1)

注意:本章代码将会建立在上一章的代码基础上,上一章链接<第八章 企业项目开发--分布式缓存memcached> 1.为什么用Redis 1.1.为什么用分布式缓存(或者说本地缓存存在的问题)? 见<第八章 企业项目开发--分布式缓存memcached> 1.2.有了memcached,为什么还要用redis? 见<第一章 常用的缓存技术> 2.代码实现 2.1.ssmm0 pom.xml 只在dev环境下添加了以下代码: <!-- redis:多台服务器支架用什么

企业项目开发--分布式缓存Redis

第九章 企业项目开发--分布式缓存Redis(1) 注意:本章代码将会建立在上一章的代码基础上,上一章链接<第八章 企业项目开发--分布式缓存memcached> 1.为什么用Redis 1.1.为什么用分布式缓存(或者说本地缓存存在的问题)? 见<第八章 企业项目开发--分布式缓存memcached> 1.2.有了memcached,为什么还要用redis? 见<第一章 常用的缓存技术> 2.代码实现 2.1.ssmm0 pom.xml 只在dev环境下添加了以下代码

Linux下搭建Memcached缓存系统

首先说下抱歉,博主最近单位经常加班,博客更新有点慢,希望大家理解,草稿箱里存了不少内容,等不忙时候一点点填坑~ 在一般的网站开发学习时候,都会把数据存放在RDBMS(关系型数据库系统(Relational Database Management System)中,服务器程序通过读取RDBMS来取得数据显示在页面上.这在我们以往编写练习项目时候,是没有任何问题的.根据木桶理论,一只水桶能装多少水取决于它最短的那块木板,在实际的网站开发中,随着数据量的增大,访问的集中,就会出现RDBMS的负担加重.

memcached缓存服务器介绍及其安装过程

Memcache是什么? memcached是以LiveJournal旗下Danga Interactive 公司的Brad Fitzpatric 为首开发的一款软件.现在 已成为mixi.hatena.Facebook.Vox.LiveJournal等众多服务中提高Web应用扩展性的重要因素. Memcached是一款开源.高性能.分布式内存对象缓存系统,可应用各种需要缓存的场景,其主要目的是通过降低对Database的访问来加速web应用程序.许多Web应用都将数据保存到RDBMS中,应用服

redis和memcached缓存

memcached memcache开源的,高性能,高并发分布式内存缓存系统,天生支持集群 memcached下载地址: http://memcached.org/downloads python实现memcached缓存 pip3 install python-memcached import memcache aa=memcache.Client(["10.0.0.20:11211"],debug=True) aa.set("k1","v1"

memcached 缓存数据库应用实践

1.1 数据库对比 缓存: 将数据存储到内存中,只有当磁盘胜任不了的时候,才会启用缓存   缺点:断电数据丢失(双电),用缓存存储数据的目的只是为了应付大并发的业务. 数据库: mysql(关系型数据库,能够保证数据一致性,保证数据不丢失,当因为功能太多,导致性能不高) ===数据参考 缓存数据库:  memcache redis(非关系型数据库,性能极高,但不保证数据完整性) === 业务的数据提供者           memcachedb 会将内存的数据写入到磁盘中   redis 主要工

基于Python项目的Redis缓存消耗内存数据简单分析(附详细操作步骤)

目录 1 准备工作 2 具体实施   1 准备工作 什么是Redis? Redis:一个高性能的key-value数据库.支持数据的持久化,可以将内存中的数据保存在磁盘中,重启的时候可以再次加载进行使用:提供string.list.set.zset.hash等数据结构的存储,并支持数据的备份. 本文适合使用的场景:当一个项目中Redis缓存的数据量逐渐增大,Redis缓存的数据占用内存也会越来越大,而且其中有很多很可能是价值不大的数据.由于Redis是一个key-value数据库,所以对其中的数