我对于Memcached的接触，还是在去年看了CSDN的一系列国外大型网站架构设计而开始的。最初的时候只是简单的封装了Memcached Java版的客户端，主要是对于配置的简化以及Memcached多点备份作了一些工作，然后就作为ASF的组件一部分提供给其他Team使用。其实看过Memcached Java客户端代码的人就会了解其实客户端的事情很简单，就是要有一套高性能的Socket通信框架以及对Memcached的私有协议实现的接口，自己去做这些事情也是很简单的，不过既然有可以满足自己需求的开源部分，那么就去实现自己需要的但没有实现的。这里我用的是Whalin的客户端版本，这里为什么还要提出来讲这个，后面会提到。
在对Java客户端作了简单封装和扩展以后，由于其他Team使用的没有什么特殊需求，也就没有再去做太多的修改，直到最近自己的服务集成平台需要做服务访问控制，才重新丰富了Cache组件，也就是这个过程中对于Memcached的一些特性和小的细节有了一些新的认识。
作为服务集成平台需要对服务有所监控，包括访问频率控制以及访问次数控制。频率控制其实很类似于硬件方面的频率控制，例如硬件可以对IP的高频率访问视为攻击，列入黑名单。而作为服务的访问，对于服务访问者的控制其实涉及到了业务参数，那么硬件就不是很适合去做这方面的控制，为此我也考虑了很久，最开始打算在Apache上做一个模块控制，但是最后觉得还是放在后面的业务框架上做这件事情。当然后面我说说的方案可能并不好，但是也算是一种想法。要把频繁的访问数据记录下来同时分析，那么数据库肯定是不行的，最简单的方式就是采用Cache，又因为是集群范围内的控制，那么集中式Cache就非Memcached莫数了（分布式的Cache传播本身损耗太大，集中式Cache本来的最大缺点就是单点，但作简单的备份操作就可以基本解决此类问题）。
作为解决这个问题的方法来说只需要实现两部分工作：访问计数器，定时任务。定时任务在我做日志分析框架的时候都是采用了Jdk5的Concurrent包里面的ScheduledExecutorService，这个作简单的循环任务足够用了，同时也是有很好的多线程异步支持，复杂一点么用Quartz。计数器就要靠Memcached来实现了，本来一般的Cache最大的问题就是高并发下的事务保证，如果采用Get+Set 来完成计数的话，那么高并发下计数器就会出现读写不一致性的问题，幸好Memcached提供了计数累加功能，让这种累加动作能够在服务端一次做好，服务端控制并发写入，保证数据的一致性。
下面就看看以下几个方法：
boolean storeCounter(String key, long count)：存储key的计数器，值为count。
long getCounter(String key)：获取key的计数器，如果不存在返回-1。
long addOrDecr(String key, long decr)：计数器值减去decr，如果计数器不存在，保存decr作为计数器值
long addOrIncr(String key, long inc)：计数器值增加inc，如果计数器不存在，保存inc作为计
数器值
long decr(String key, long decr)：与addOrDecr不同的是在计数器不存在的时候不保存任何值，返回-1
long incr(String key, long inc) ：与addOrIncr不同的是在计数器不存在的时候不保存任何值，返回-1
这里需要说明几点：
storeCounter和普通的set方法不同，如果通过set方式置入key:value的话，getCounter等其他四个方法都认为技术器不存在。所以Counter的存储方式是和普通内容存储不同的。
在不同的场景要慎用addOrXXXX和XXXX的方法，两者还是有比较大的区别的。
计数器没有提供移除特殊方法，使用delete方法可以移除计数器，但是频繁的delete和addOrXXXX有时候会出现一些奇怪的问题（例如同名的计数器就没有办法再次被创建，不过这个还
需要进一步的去研究一下看看）。一般情况下如果计数器的key不是很多，同时也会被复用，那么可以通过置为0或者减去已经分析过的数量来复位。
有上面的一套计数器机制就可以很方便的实现Memcached的计数功能，但是又一个问题出现了，如何让定时任务去遍历计数器，分析计数器是否到了阀值，触发创建黑名单记录的工作。早先我同事希望我能够提供封装好的keySet接口，但是我自己觉得其实作为Cache来说简单就是最重要的，Cache不需要去遍历。首先使用Cache的角色就应该知道Key，然后去Cache里面找，找不到就去后台例如DB里面去搜索，然后将搜索的结果在考虑更新到Cache里面，这样才是最高效并且最可靠的，Cache靠不住阿，随时都可能会丢失或者崩溃，因此作为类似于一级缓存或者这类数据完整性要求不
高，性能要求很高的场景使用最合适。当时就没有提供这样的接口，直到今天自己需要了，才考虑如何去做这件事情。
开始考虑是否能够将key都记录在另外的Cache中或者是Memcached中，首先在高并发下更新操作就是一大问题，再者Memcached的内存分配回收机制以及Value的大小限制都不能满足这样的需求，如果使用数据库，那么频繁更新操作势必不可行，采用异步缓存刷新又有一个时间间隔期，同时更新也不是很方便。最后考虑如果能够让Memcached实现Keyset那么就是最好的解决方案，网上搜索了一下，找到一种策略，然后自己优化了一下，优化后的代码如下：
@SuppressWarnings("unchecked")
public Set keySet(int limit,boolean fast)
{
Set
Map
Map slabs = getCacheClient().statsItems();
if (slabs != null && slabs.keySet() != null)
{
Iterator itemsItr = slabs.keySet().iterator();
while(itemsItr.hasNext())
{
String server = itemsItr.next().toString();
Map itemNames = (Map) slabs.get(server);
Iterator itemNameItr = itemNames.keySet().iterator();
while(itemNameItr.hasNext())
{
String itemName = itemNameItr.next().toString();
// itemAtt[0] = itemname
// itemAtt[1] = number
// itemAtt[2] = field
String[] itemAtt = itemName.split(":");
if (itemAtt[2].startsWith("number"))
dumps.put(itemAtt[1],
Integer.parseInt(itemAtt[1]));
}
}
if (!dumps.values().isEmpty())
{
Iterator
while(dumpIter.hasNext())
{
int dump = dumpIter.next();
Map cacheDump = statsCacheDump(dump,limit);
Iterator entryIter = cacheDump.values().iterator();
while (entryIter.hasNext())
{
Map items = (Map)entryIter.next();
Iterator ks = items.keySet().iterator();
while(ks.hasNext())
String k = (String)ks.next();
try
{
k = URLDecoder.decode(k,"UTF-8"); }
catch(Exception ex)
{
Logger.error(ex);
}
if (k != null && !k.trim().equals("")) {
if (fast)
keys.add(k);
else
if (containsKey(k))
keys.add(k);
}
}
}
}
}
return keys;
}
对于上面代码的了解需要从Memcached内存分配和回收机制开始，以前接触Memcached的时候只是了解，这部分代码写了以后就有些知道怎么回事了。Memcached为了提高内存的分配和回收效率，采用了slab和dump分区的概念。Memcached一大优势就是能够充分利用Memory资源，将同机器或者不同机器的Memcached服务端组合成为对客户端看似统一的存储空间，Memcached 可以在一台机器上开多个端口作为服务端多个实例，也可以在多台机器上开多个服务实例，而slab 就是Memcached的服务端。下面是我封装后的Cache配置：
defaultEncoding="UTF-8" socketpool="pool0">
defaultEncoding="UTF-8" socketpool="pool1">
defaultEncoding="UTF-8" socketpool="pool11">
nagle="false" socketTO="3000" aliveCheck="true">
nagle="false" socketTO="3000" aliveCheck="true">
nagle="false" socketTO="3000" aliveCheck="true">
可以看到其实pool才是最终连接服务端的配置，看看pool0，它会连接
10.2.225.210:13000,10.2.225.210:13001,10.2.225.210:13002这些机器和他们的端口，但是对于使用pool0的mclient0来说它仅仅只是知道有一个叫做mclient0的cache可以保存数据。此时slab就有三个：10.2.225.210:13000和
10.2.225.210:13001和10.2.225.210:13002。
当一个key:value要被放入到Memcached中，首先Memcached会根据key的hash算法获取到hash值来选择被分配的slab，然后根据value选择适合的dump区。所谓dump区其实就是根据value的大小来将内存按照存储单元内容大小分页。这个是可以配置Memcached的，例如Memcached将slab中的内存划分成4个dump，第一dump区存储0-50k大小的数据，第二dump 区存储50-100k的数据，第三dump区存储100-500k的数据,第四dump区存储500-1000K的
数据。那么当key:value需要被写入的时候，很容易定位到value所处的dump，分配内存给value。这种分dump模式简化内存管理，加速了内存回收和分配。但是这里需要注意的几点就是，首先当你的应用场景中保存的数据大小离散度很高，那么就不是很适合Memcached的这种分配模式，容易造成浪费，例如第一dump区已经满了，第二第三dump区都还是只有一个数据，那么第二第三dump 区不会被回收，第二第三dump区的空间就浪费了。同时Memcached对于value的大小支持到1M,大于1M的内容不适合Memcached存储。其实在Cache的设计中这样的情况发生本来就证明设计有问题，Cache只是加速，一般保存都是较小的id或者小对象，用来验证以及为数据定位作精准细化，而大数据量的内容还是在数据库等存储中。
知道了基本的分配机制以后再回过头来看看代码：
Map slabs = getCacheClient().statsItems();//获取所有的slab
//用来收集所有slab的dump号
while(itemsItr.hasNext())
{
String server = itemsItr.next().toString();
Map itemNames = (Map) slabs.get(server);
Iterator itemNameItr = itemNames.keySet().iterator();
while(itemNameItr.hasNext())
{
String itemName = itemNameItr.next().toString();
// itemAtt[0] = itemname
// itemAtt[1] = number
// itemAtt[2] = field
String[] itemAtt = itemName.split(":");
// 如果是itemName中是:number来表示，那么证明是一个存储数据的dump，还有一些是age的部分
if (itemAtt[2].startsWith("number"))
dumps.put(itemAtt[1],
Integer.parseInt(itemAtt[1]));
}
}
//根据收集到的dump来获取keys
if (!dumps.values().isEmpty())
{
Iterator
while(dumpIter.hasNext())
{
int dump = dumpIter.next();
// statsCacheDump支持三个参数String[],int,int，第一个参数可以省略，默认填入null，表示从那些slab中获取dump号为第二个参
数的keys，如果是null就从当前所有的slab中获取。第二个参数表示
dump号，第三个参数表示返回最多多少个结果。
Map cacheDump = statsCacheDump(dump,limit);
Iterator entryIter = cacheDump.values().iterator();
while (entryIter.hasNext())
{
Map items = (Map)entryIter.next();
Iterator ks = items.keySet().iterator();
while(ks.hasNext())
{
String k = (String)ks.next();
try
{
//这里为什么要作decode，因为其实在我使用的这个java
客户端存储的时候，默认会把key都作encoding一次，所以必
须要做，不然会出现问题。
k = URLDecoder.decode(k,"UTF-8");
}
catch(Exception ex)
{
Logger.error(ex);
}
if (k != null && !k.trim().equals(""))
{
//这里的fast参数是在方法参数中传入，作用是什么，其实
采用这种搜索slab以及dump的方式获取keys会发现返回的可
能还有一些已经移除的内容的keys，如果觉得需要准确的keys，
就在做一次contains的检查，不过速度就会有一定的影响。
if (fast)
keys.add(k);
else
if (containsKey(k))
keys.add(k);
}
}
}
}
}
至此，整个keySet的问题解决了，对于即时监控也基本都作好了，这里需要把过程中的两件小事情说一下。
1.statsCacheDump始终不能用。
刚开始的时候statsCacheDump方法始终报错说连接超时，跟踪到了java客户端代码中发现并不是什么连接超时，只是服务端返回了错误信息，而客户端认为还没有结束一直等待，导致超时。我就顺手给java客户端的开发人员mail了信息求助（代码里面有email）。再仔细看了看出错信息，返回的是不认识该指令的错误，因此就去解压memcached的服务端，看了看它的协议说明，这个Stat方法还是有的，很奇怪，没有办法了，虽然自己对于c不是很懂，但起码大致看懂逻辑还是不难，下载了Memcached的源码一看，发现居然对于StatsCacheDump这个方法调用必须还有一个参数limit，在我手头的客户端代码里面就没有这个参数，所以错误了，本来想扩展一下那个方法，但是那个方法中实现的不是很好，都是private的不容易扩展，这时候居然收到其中一个客户端开发者的回复邮件，说我手头的代码太老了，同时不建议去实现keyset，认为这样比较低效。我去下载了一个新版本，看了看源码果然已经修复了，我就回了邮件表示感谢，同时也和他说明了这么做的原因。因此大家如果要和我一样写上面的代码，就需要它2.0.1的那个版本。这里对那些国外的开源工作者表示敬佩，对于开发者是很负责任的。
2．关于fast那个选项
这个是我加上去的，做了一下测试，例如我先执行如下代码：
Cache.set(“key1”,”value1”);
Ca che.set(“key2”,”value2”);
Cache.flushAll(null);
Cache.set(“key3”,”value3”);
Cache.set(“key4”,”value4”);
Boolean fast = true;
Set keys = Cache.keySet(fast);
System.out.println(keys);
Fast = false;
keys = Cache.keySet(fast);
System.out.println(keys);
得到的结果为：
Key1,key2,key3,key4
Key3,key4
可以看到其实如果通过StatsCacheDump来获取得到的keys会参杂一些已经失效的keys,只是没有回收，本来尝试获取时间戳来做判断，不过还不如使用containsKey来的有效。
同时这里采用containsKey而不是用get，就是因为counter是不能用get获得的，即使counter存在。
这些就是今天在使用Memcached所收获的，分享一下，如果有一些理解上的偏差也希望能够被指出。
Memcached 源码剖析笔记 Xguru Memcached是一个自由、源码开放、高性能、分布式 内存对象缓存系统，目的在于通过减轻数据库负载来使 动态Web应用程序提速。
目录 1.背景 (3) 2.memcached的安装 (4) 3.memcached的配置 (5) 4.memcached的使用 (6) 4.1.存储命令 (7) 4.2.读取命令 (8) 4.3.删除命令 (8) 4.4.高级命令 (9) 4.5.其他命令 (10) 5.Memcached内部工作机制 (11) 5.1.Memcached基本的数据结构 (11) 5.2.基本设计概念和处理流程 (12) 5.3.内部Hash机制 (15) 5.3.1.Hash函数及冲突解决 (15) 5.3.2.HashTable主要函数 (15) 5.4.slab内存处理机制 (17) 5.4.1.slab主要函数 (17) 5.4.2.slab机制中所采用的LRU算法 (19) 5.5.控制item各种函数 (20) 5.6.守护进程机制 (22) 5.7.Socket处理机制 (23) 1
5.7.1.Unix域协议 (23) 5.7.2.TCP/UDP协议 (24) 5.8.多线程处理机制 (25) 5.9.事件处理机制 (25) 6.未完善之处 (27) 7.参考文献 (28) 2
1.背景 Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提供动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。 Memcached是一个自由、源码开放、高性能、分布式内存对象缓存系统，目的在于通过减轻数据库负载来使动态Web应用程序提速。 Memcached是一个在内存中对任意的数据（比如字符串，对象等）所使用的key-value 存储。数据可以来自数据库调用，API调用，或者页面渲染的结果。 Memcached设计理念就是小而强大，它简单的设计促进了快速部署、易于开发，并解决面对大规模的数据缓存的许多难题。所开放的API能用于大部分流行的程序语言 3
目录 第一阶段、Spring Boot从入门到精通（10小时） (1) 第二阶段、小型电商网站开发+设计模式+架构设计+项目管理（20小时） (2) 第三阶段、Spring Cloud从入门到精通（20小时） (3) 第四阶段、电商网站的微服务架构（20小时） (3) 第五阶段、高并发大型电商网站架构（150小时） (4) 第六阶段、高可用大型电商网站架构（30小时） (6) 第七阶段、高性能大型电商架构（30小时） (7) 第八阶段、亿级流量的大型电商系统架构（150小时） (7) 第九阶段、自己动手做多租户SaaS云ERP系统 (8) 第十阶段、底层技术+微服务中间件（50小时） (9) 第十一阶段、自己动手写仿Storm的实时计算中间件 (10) 第十二阶段、开源框架源码阅读+定制化开发mvc/ioc/orm框架（50小时） (10) 第十三阶段、自己动手写工作流框架 (10) 授课方式说明 (10) 学习进度说明 (11) 就业指导说明 (12) 学习成果说明 (12) 2万费用说明 (13) 讲师课程质量以及是否会跑路 (14) 第一阶段、Spring Boot从入门到精通（10小时） 目前市面上所有的视频课程以及书籍，都只是简单介绍Spring Boot的基础知识，没有任何一套资料深入讲解这两个技术的。而如果你自己跟着官网慢慢看，全英文官网，估计大部分同学都很难看的懂，或者学习速度非常慢。 我会将Spring Boot的所有核心技术点以及高阶技术点，全部嚼烂咬碎，深度提炼，用最精炼的语言，给大家讲透，让大家在最短的时间内彻底掌握这个未来绝对主流的开发框架，为未来的高阶的项目打好扎实的基础。 强调一下，这块技术讲解，绝对不会采取拖延时间，以及碎碎念的方式，一点一点细节慢慢
《网络协议栈分析与设计》大作业 边界网关协议(BGP)RFC分析与设计Border Gateway Protocol 学生：吕卿网络1101班 201192334 2013/12/16
1.背景介绍 边界网关协议是用来连接网络上不同自治系统（AS）的路由选择协议。BGP是为了取代最初的外部网关协议EGP所设计的，也被认为是路径矢量协议。它通过维护IP路由表和前缀表来实现自治系统（AS）间的可达性。BGP的主要功能是和其他BGP系统交换网络可达性信息。必须要注意的是BGP是建立在可靠连接的基础之上的。 2.操作总结 在两个系统建立的连接中他们互相交互信息更改数据。初始数据流是整个BGP路由表。BGP不要求整个BGP路由表的周期性更新。保持存活信息定期的被发送以确保连接的存活。通知信息被发送来回馈错误通知和特殊情况。执行边际路由协议的主机不必是路由器。一个非路由器的主机可以和路由器经由EGP甚至内部路由协议进行交互。如果一个特殊的自治系统（AS）有多个BGP发言者，那么一定要注意在一个AS内要的几个发言者要有一致的路由视野。 3.信息格式 信息在可靠传输协议连接上发送。信息只有在被完全接收之后才能够被处理。最大的信息大小是4096字节。所有的实现必须支持这一最大信息规格。最小的数据规格要包含BGP头部不含数据部分。 3.1数据头格式 每个信息有个固定大小的头部。包括标识物·长度·类型。标识物：这16字节大小的领域包含信息接收方可以对信息进行确认的信息。长度：这2字节无符号整数表明这则信息的总长度。长度的值必须在19到4096之间类型：这一字节无符号整数表明这则信息的代码模式。共有四种类型： 1 - OPEN 2 - UPDATE 3 - NOTIFICATION 4 - KEEPALIVE
豆瓣整个基础架构可以粗略的分为在线和离线两大块。在线的部分和大部分网站类似：前面用，用Nginx做反向代理，形成负载均衡的一层;应用层主要是做运算，将运算结果返回给前面的DAE平台是这两年建起来的，现在大部分豆瓣的应用基本都跑在DAE上面了;应用后面的基
以DPark能够大幅提升性能。另外，因为DPark的编写使用了函数式语言的特点，所以可以写的非常简洁： 到目前(2014年3月)，DPark的集群规模和处理数据量已经比去年多了一倍左右，一天要处 理60~100T B左右的数据。 团队 当前，我所负责的豆瓣平台部一共包括四个部分：核心系统，这块也是由我直接带领的，共6名工程师;DAE，现在是彭宇负责，共4名工程师;DBA两人;SA两人。 平台部负责的项目大多是跟业务无关的东西，贴近应用层的主要在产品线团队做，这个分工跟豆瓣工程团队的发展历史有关。早期豆瓣工程师还不多的时候，就已经分为两种倾向，一种是偏业务的，就是去做用户能看得见的东西;另一种是支持性的，运行在业务层下面、不被用户所感知的东西。下面这一层就衍变成了平台部门。 在豆瓣，不管是做产品还是做平台的工程师，技术实力都比较强，一个项目应该从哪个部门发起，并不是看这个任务的难度，而是看它是公共的还是业务特有的。有些项目即使未来可能会成为公共的，但一开始只是一个产品线需要，那么它也会从产品线发起。比如豆瓣的短信服务，最开始是产品线有需求，所以这些服务都是由他们发起完成的，平台这边主要负责提供建设服务的架构，比如DoubanService，告诉他们一个服务怎样去写、怎样去部署、怎样去对用户开放。短信服务后来成为很多产品线都在使用的服务，同时这个系统本身也越来越成熟，那么它逐渐就被转移到SA团队来进行维护。
一个社交App需实现的功能 用户关注的常规社交功能、活动、地理位置、探索功能、新鲜事、视频照片分享等等，需要提供的功能不胜枚举，所以从技术角度来说，开发者需要解决的问题也是异常复杂的。 当一款社交App发布之初，用户访问量比较小，使用一台服务器就能够支撑全部的访问压力和数据存储需求，但是互联网应用具有病毒式的传播特点。一款App很可能会面临一夜爆红的现象，访问量和数据量在短时间内呈现爆发式增长，这时候会面临的局面是每天上亿PV、数百万新增用户和活跃用户、流量飙升至每秒数百兆。这些对于一个只部署了简单后端架构的应用来讲是无法支撑的，会直接导致服务器响应缓慢甚至超时，以及在高峰期时服务呈现瘫痪状态，使得后端的服务完全无法使用，用户体验急剧下降。本文将会通过一个真实的案例来分享一个社交应用如何构建一个具备高伸缩性的后端系统。 社交App最初部署的后端架构解析 社交App在最初的时候，后端架构相对比较简单，最初是部署在基础网络之上。最前面放置一台绑定了公网IP的nginx服务器作负载均衡，后面放置3台应用服务器来负责处理所有业务上的请求，最后面搭建一台MySQL Database数据库。 构建私有网络 随着产品的不断迭代、用户数的持续增长、数据量的积累，App就需要改进自己的后端架构，即开始构建私有网络。用户可以使用私有网络构建自己的网络拓扑——创建路由器和私有网络，将后续加入的用于运行内部服务的主机放置在私用网络中，可以有效地和云平台其他用户主机，在网络上实现100%二层隔离。主机对外开放的仅仅只有80端口，这样系统安全性上多了一层保障。
在上面的架构图中，最前面的是防火墙，后面接负载均衡器，然后接路由器和私有网络，很多互联网应用都存在读多写少的情况，这个比例有时可以达到8:2，所以我们首先通过引入缓存分摊数据库读压力。其次，引入负载均衡器，替换最初架构中的nginx proxy，负责均衡器在这里其主要用于分发请求到后端多台应用服务器，，当其中一台应用服务器挂掉，负载均衡器可以进行自动隔离。 业务分区与扩展 App随着并发访问量和数据量不断增大，首先想到横向扩容Web服务。水平扩容业务服务器的前提是要保证每台服务器都是无状态的，将session信息下放到缓存或数据库中存储，保证请求被负载到任何一台服务器可以正常处理。
PHP大型网站的架构实例分析 Poppen.de是德国的一个社交网站，相对Facebook、Flickr来说是一个很小的网站，但它有一个很好的架构，融合了很多技术，如 Nigix、MySql、CouchDB、Erlang、Memcached、RabbitMQ、PHP、Graphite、Red5以及Tsung. 统计信息 200万注册用户数； 2万并发用户数； 每天20万条私有消息； 每天25万登录次数； 项目团队有11个开发人员，两个设计，两个系统管理员； 商业模式 该网站采用免费增值模式，用户可以免费使用下面任何服务： 搜索其他用户； 给好友发送消息； 上载图片和视频； 寻找好友； 视频聊天； 更多… 但如果用户想享受不受限制发送消息和上载图片，那么就得根据需要支付不同类型的会员服务，视频聊天及网站其他服务也采用同样的策略。 工具箱 Nginx Poppen.de 所有的服务都是基于Nginx服务上的。前端有两台Nginx服务器在高峰期提供每分钟15万次请求的负载，每个机器已经有四年寿命，并且只有一个CPU和3GB RAM.Poppen.de拥有三台独立的图像服务器，由三台Nginx服务器为*.bilder.poppen.de提供每分钟8万次请求服务。
Nginx架构中一个很酷的设计就是有很多请求是由Memcached处理的，因此请求从缓存中获取内容而不需要直接访问PHP机器。比如，用户信息页（user profile）是网站需要密集处理的内容，如果把用户信息页全部缓存到Memcached 上，那么请求直接从Memcached上获取内容。Poppen.de的Memcached每分钟可以处理8000次请求。 架构中有三个Nginx图像服务器提供本地图像缓存，用户上载图像到一个中央文件服务器。当向这三个Nginx之一中请求图像时，如果服务器本地中没有存在该图像，则从中央文件服务器下载到该服务器上作缓存并提供服务。这种负载均衡的分布式图像服务器架构设计可以减轻主要存储设备的负载。 PHP-FPM 该网站运行在PHP-FPM上。共有28台双CPU、6GB内存的PHP机器，每个机器上运行100个PHP-FPM的工作线程。使用启用了APC的PHP5.3.x. PHP5.3可以降低CPU和内存使用率的30%以上。 程序代码是基于Symfony1.2框架之上开发的。一是可以使用外部资源，二是能够提高项目开发进度，同时在一个著名的框架上可以让新开发人员更容易加入到团队中来。虽然没有任何事情都是十全十美的，但可以从Symfony框架中得到很多好处，让团队可以更多的精力放在Poppen.de的业务开发上去。 网站性能优化使用XHProf，这是Facebook开源出来的一个类库。这个框架非常容易个性化和配置，能够可以缓存大部分高代价的服务器计算。 MySQL MySQL是网站主要的RDBMS.网站又几个MySql服务器：一台4CPU、32GB的服务器存储用户相关信息，如基本信息、照片描述信息等。这台机器已经使用了4年，下一步计划会使用共享集群来替换它。目前仍基于这个系统上进行设计，以简化数据访问代码。根据用户ID进行数据分区，因为网站中大部分信息都是以用户为中心的，如照片、视频、消息等。 有三台服务器按主-从-从配置架构提供用户论坛服务。一台从服务器负责网站自定义消息存储，到现在有2.5亿条消息。另外四台机器为主-从配置关系。 另外由4台机器配置成NDB族群专门服务于密集型写操作数据，如用户访问统计信息。 数据表设计尽量避免关联操作，尽可能缓存最多的数据。当然，数据库的结构化规范已经完全被破坏掉了。因此，为了更容易搜索，数据库设计创建了数据挖掘表。 大部分表是MyISAM型表，可以提供快速查找。现在的问题是越来越多的表已经全表锁住了。Poppen.de正考虑往XtraDB存储引擎上迁移。
memcached分析详解
目录 1.文档目的 (1) 1.1.前言 (1) 2.memcached是什么 (2) 2.1. memcached的特征 (2) 3.memcached适合的场合 (4) 4.memcached的代码分析 (5) 4.1. main流程 (5) 4.2. memcached服务流程(TCP) (6) 4.3. memcached状态转换和通信协议处理 (7) 4.4. memcached核心数据结构 (7) 4.5. Slab Allocation机制：整理内存以便重复使用 (8) 5.memcached的使用优化 (10) 5.1. 命中率 (10) 5.2. 空间利用率 (11) 5.3. 加速比 (12) 5.4. 安全性能 (12) 6.memcached的测试分析 (13) 6.1. 读写memcache指令测试 (13) 6.2. 服务端系统负载 (13) 6.3. 空间分配,命中率 (14) 7.memcached的中间层客户端编写 (16) 8.libevent简介 (17) 9.memcached应用 (18) 10.结束语 (20)
1. 文档目的 1.1. 前言 文档就是简单的把memcached做一个代码走读和分析,起到一个抛砖引玉的作用; 目的就是让大家在使用memcached这个工具时,多一些对工具的了解,从而确定你的程序是否真的需要用memcached来实现不可; 短短2个小时也讲不了多少,主要是做一个学习探讨,如果大家感兴趣的话后期可以再做培训 牛人真多啊，向先行者致敬！
2. memcached是什么 memcached广泛应用在大负载高并发的网站上，是一种非常成熟的产品（称为一项技术也未尝不可）。像facebook，youtube,yahoo,sina，sohu，netease，豆瓣等网站均或多或少使用了该项产品。memcached在以用户为中心的网站上，表现尤其突出，例如sns,blog等web2.0应用的站点。这些站点一般来讲，特别注重用户体验，用户对服务器的响应速度要求很高，用户数据相对比较复杂、关连度比较高，需要经常对数据库进行更新和检索。 许多Web应用都将数据保存到RDBMS中，应用服务器从中读取数据并在浏览器中显示。但随着数据量的增大、访问的集中，就会出现RDBMS的负担加重、数据库响应恶化、网站显示延迟等重大影响。 这时就该memcached大显身手了。memcached是高性能的分布式内存缓存服务器。一般使用目的是，通过缓存数据库查询结果，减少数据库访问次数，以提高动态Web应用的速度、提高可扩展性。 2.1. memcached的特征 1）memcached的服务器客户端通信并不使用复杂的XML等格式，而使用简单的基于文本行的协议。因此，通过telnet 也能在memcached上保存数据、取得数据。下面是例子。 $ telnet localhost 8119 Trying 127.0.0.1... Connected to localhost.localdomain (127.0.0.1). Escape character is '^]'. set foo 0 0 3 （保存命令） bar （数据）
memcached全面剖析 作者：长野雅广(Masahiro Nagano) 作者：前坂徹(Toru Maesaka) 翻译：charlee 整理：yaykey 发表时间：2008/07/02‐2008/07/30 翻译时间：2008/07/10‐2008/07/31 整理时间：2010/11/09
原文链接： http://gihyo.jp/dev/feature/01/memcached/0001 http://gihyo.jp/dev/feature/01/memcached/0002 http://gihyo.jp/dev/feature/01/memcached/0003 http://gihyo.jp/dev/feature/01/memcached/0004 http://gihyo.jp/dev/feature/01/memcached/0005 译文地址: ?第1次：https://www.doczj.com/doc/53296973.html,/2008/07/10/memcached‐001/ ?第2次：https://www.doczj.com/doc/53296973.html,/2008/07/11/memcached‐002/ ?第3次：https://www.doczj.com/doc/53296973.html,/2008/07/16/memcached‐003/ ?第4次：https://www.doczj.com/doc/53296973.html,/2008/07/24/memcached‐004/ ?第5次：https://www.doczj.com/doc/53296973.html,/2008/07/31/memcached‐005/ 2 / 81
目录 1. memcached完全剖析–1. memcached的基础 (5) 1.1. memcached是什么？ (7) 1.2. memcached的特征 (9) 1.2.1. 协议简单 (9) 1.2.2. 基于libevent的事件处理 (9) 1.2.3. 内置内存存储方式 (10) 1.2.4. memcached不互相通信的分布式 (10) 1.3. 安装memcached (11) 1.3.1. memcached的安装 (11) 1.3.2. memcached的启动 (12) 1.4. 用客户端连接 (13) 1.5. 使用Cache::Memcached (15) 1.5.1. 使用Cache::Memcached连接memcached (16) 1.5.2. 保存数据 (17) 1.5.3. 获取数据 (17) 1.5.4. 删除数据 (17) 1.5.5. 增一和减一操作 (18) 1.6. 总结 (19) 2. memcached全面剖析–2.理解memcached的内存存储 (21) 2.1. Slab Allocation机制：整理内存以便重复使用 (23) 2.1.1. Slab Allocation的主要术语 (24) 2.1.1.1. Page (24) 2.1.1.2. Chunk (24) 2.1.1.3. Slab Class (24) 2.2. 在Slab中缓存记录的原理 (25) 2.3. Slab Allocator的缺点 (27) 2.4. 使用Growth Factor进行调优 (29) 2.5. 查看memcached的内部状态 (31) 2.6. 查看slabs的使用状况 (33) 2.7. 内存存储的总结 (35) 3. memcached全面剖析–3.memcached的删除机制和发展方向 (37) 3.1. memcached在数据删除方面有效利用资源 (39) 3.1.1. 数据不会真正从memcached中消失 (39) 3.1.2. Lazy Expiration (39) 3.2. LRU：从缓存中有效删除数据的原理 (41) 3.3. memcached的最新发展方向 (43) 3.3.1. 关于二进制协议 (43) 3.3.2. 二进制协议的格式 (43) 3.3.3. HEADER中引人注目的地方 (45) 3.4. 外部引擎支持 (47) 3 / 81