上周参加Qcon，有个兄弟分享秒杀系统的优化，其观点有些赞同，大部分观点却并不同意，结合自己的经验，谈谈自己的一些看法。

一、为什么难

秒杀系统难做的原因：库存只有一份，所有人会在集中的时间读和写这些数据。

例如小米手机每周二的秒杀，可能手机只有1万部，但瞬时进入的流量可能是几百几千万。

又例如12306抢票，亦与秒杀类似，瞬时流量更甚。

二、常见架构

流量到了亿级别，常见站点架构如上：

1）浏览器端，最上层，会执行到一些JS代码

2）站点层，这一层会访问后端数据，拼html页面返回给浏览器

3）服务层，向上游屏蔽底层数据细节

4）数据层，最终的库存是存在这里的，mysql是一个典型

三、优化方向

1）将请求尽量拦截在系统上游：传统秒杀系统之所以挂，请求都压倒了后端数据层，数据读写锁冲突严重，并发高响应慢，几乎所有请求都超时，流量虽大，下单成功的有效流量甚小【一趟火车其实只有2000张票，200w个人来买，基本没有人能买成功，请求有效率为0】

2）充分利用缓存：这是一个典型的读多些少的应用场景【一趟火车其实只有2000张票，200w个人来买，最多2000个人下单成功，其他人都是查询库存，写比例只有0.1%，读比例占99.9%】，非常适合使用缓存

四、优化细节

4.1）浏览器层请求拦截

点击了“查询”按钮之后，系统那个卡呀，进度条涨的慢呀，作为用户，会不自觉的再去点击“查询”，继续点，继续点，点点点。。。有用么？平白无故的增加了系统负载（一个用户点5次，80%的请求是这么多出来的），怎么整？

a）产品层面，用户点击“查询”或者“购票”后，按钮置灰，禁止用户重复提交请求

b）JS层面，限制用户在x秒之内只能提交一次请求

如此限流，80%流量已拦

4.2）站点层请求拦截与页面缓存

浏览器层的请求拦截，只能拦住小白用户（不过这是99%的用户哟），高端的程序员根本不吃这一套，写个for循环，直接调用你后端的http请求，怎么整？

a）同一个uid，限制访问频度，做页面缓存，x秒内到达站点层的请求，均返回同一页面

b）同一个item的查询，例如手机车次，做页面缓存，x秒内到达站点层的请求，均返回同一页面

如此限流，又有99%的流量会被拦截在站点层

4.3）服务层请求拦截与数据缓存

站点层的请求拦截，只能拦住普通程序员，高级黑客，假设他控制了10w台肉鸡（并且假设买票不需要实名认证），这下uid的限制不行了吧？怎么整？

a）大哥，我是服务层，我清楚的知道小米只有1万部手机，我清楚的知道一列火车只有2000张车票，我透10w个请求去数据库有什么意义呢？对于写请求，做请求队列，每次只透过有限的写请求去数据层，如果均成功再放下一批，如果库存不够则队列里的写请求全部返回“已售完”

b）对于读请求，还用说么？cache来抗，不管是memcached还是redis，单机抗个每秒10w应该都是没什么问题的

如此限流，只有非常少的写请求，和非常少的读缓存mis的请求会透到数据层去，又有99.9%的请求被拦住了

4.4）数据层闲庭信步

到了数据这一层，几乎就没有什么请求了，单机也能扛得住，还是那句话，库存是有限的，小米的产能有限，透过过多请求来数据库没有意义。

五、总结

没什么总结了，上文应该描述的非常清楚了，对于秒杀系统，再次重复下笔者的两个架构优化思路：

1）尽量将请求拦截在系统上游

2）读多写少的常用多使用缓存

        关于这个机制网上有很多解释的，我个人的总结如下。

1. Page为内存分配的最小单位。

   Memcached的内存分配以page为单位，默认情况下一个page是1M，可以通过-I参数在启动时指定。如果需要申请内存时，memcached会划分出一个新的page并分配给需要的slab区

3.  

4.  

5. 域。page一旦被分配在重启前不会被回收或者重新分配（page ressign已经从1.2.8版移除了） 
   
   

6. Slabs划分数据空间。

   Memcached并不是将所有大小的数据都放在一起的，而是预先将数据空间划分为一系列slabs，每个slab只负责一定范围内的数据存储。如下图，每个slab只存储大于其上一个slab的size并小于或者等于自己最大size的数据。例如：slab 3只存储大小介于137 到 224 bytes的数据。如果一个数据大小为230byte将被分配到slab 4中。从下图可以看出，每个slab负责的空间其实是不等的，memcached默认情况下下一个slab的最大值为前一个的1.25倍，这个可以通过修改-f参数来修改增长比例。 
   

8.   

9. Chunk才是存放缓存数据的单位。

   Chunk是一系列固定的内存空间，这个大小就是管理它的slab的最大存放大小。例如：slab 1的所有chunk都是104byte，而slab 4的所有chunk都是280byte。chunk是memcached实际存放缓存数据的地方，因为chunk的大小固定为slab能够存放的最大值，所以所有分配给当前slab的数据都可以被chunk存下。如果时间的数据大小小于chunk的大小，空余的空间将会被闲置，这个是为了防止内存碎片而设计的。例如下图，chunk size是224byte，而存储的数据只有200byte，剩下的24byte将被闲置。 
   

11.  

12. 
     

13. Slab的内存分配。

    Memcached在启动时通过-m指定最大使用内存，但是这个不会一启动就占用，是随着需要逐步分配给各slab的。
             如果一个新的缓存数据要被存放，memcached首先选择一个合适的slab，然后查看该slab是否还有空闲的chunk，如果有则直接存放进去；如果没有则要进行申请。slab申请内存时以page为单位，所以在放入第一个数据，无论大小为多少，都会有1M大小的page被分配给该slab。申请到page后，slab会将这个page的内存按chunk的大小进行切分，这样就变成了一个chunk的数组，在从这个chunk数组中选择一个用于存储数据。如下图，slab 1和slab 2都分配了一个page，并按各自的大小切分成chunk数组。 
    

15.  

16. 
     

17. Memcached内存分配策略。

    综合上面的介绍，memcached的内存分配策略就是：按slab需求分配page，各slab按需使用chunk存储。
    这里有几个特点要注意，

    1. Memcached分配出去的page不会被回收或者重新分配
    2. Memcached申请的内存不会被释放
    3. slab空闲的chunk不会借给任何其他slab使用
       
        每一个slab=1M   切分的chunk个数=1M/最小的chunk大小
       下一个chunk=上一个chunk大小*增长因子
    4. 

    
    

      知道了这些以后，就可以理解为什么总内存没有被全部占用的情况下，memcached却出现了丢失缓存数据的问题了。
*******************
当存储的值item大于1M的时候：

  1M 用完会申请一个新的 1M

 Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提供动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程（daemon ）是用C写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。但是它并不提供冗余（例如，复制其hashmap条目）；当某个服务器S停止运行或崩溃了，所有存放在S上的键/值对都将丢失。

Memcached官方：http://danga.com/memcached/

关于Memcached的介绍请参考：Memcached深度分析

下载Windows的Server端

下载地址：http://code.jellycan.com/memcached/

@CacheKeyMethod:缓存key生成注解

---------------------------------读取-------------------------------------------

@ReadThroughAssignCache(assignedKey = "SomePhatKey", namespace = "Echo", expiration = 3000): 读取指定key缓存

@ReadThroughSingleCache(namespace = SINGLE_NS, expiration = 0):读取单个缓存

@ReadThroughMultiCache(option = @ReadThroughMultiCacheOption(generateKeysFromResult = true)):读取多个缓存

@ReadThroughMultiCacheOption(generateKeysFromResult = true) 读取多个缓存操作generateKeysFromResult 通过结果生成key

---------------------------------更新-------------------------------------------

@UpdateAssignCache(assignedKey = "SomePhatKey", namespace = "Echo", expiration = 3000): 指定key更新缓存

@UpdateSingleCache(namespace = SINGLE_NS, expiration = 2): 更新单个缓存(namespace 命名空间, expiration 失效时间单位秒)

@UpdateMultiCache(namespace = "Bravo", expiration = 300): 更新多个缓存

---------------------------------失效-------------------------------------------

@InvalidateAssignCache(assignedKey = "SomePhatKey", namespace = "Echo") : 指定key失效缓存

@InvalidateSingleCache(namespace = SINGLE_NS):失效单个缓存

@InvalidateMultiCache(namespace = "Delta") : 失效多个缓存

---------------------------------参数-------------------------------------------

@ParameterDataUpdateContent: 标记方法的参数作为更新内容。这个注解应结合Update*Cache注解使用

@ParameterValueKeyProvider: 标记将方法的参数做为计算缓存key.如果方法被注解的对象标记CacheKeyMethod的方法将会用来生成缓存key否则调用toString()生成

@ParameterValueKeyProvider(order=0) 属性表示如果多个参数做为key时需提供参数顺序

与@ParameterValueKeyProvider类似的注解有:

{

  @ReturnValueKeyProvider: 返回值对象中计算key

}

---------------------------------泛型处理-------------------------------------------

@BridgeMethodMappings({ @BridgeMethodMapping(methodName = "updateUser", 

erasedParamTypes = { Object.class }, targetParamTypes = { AppUser.class }) }): 泛型桥接注解

methodName : 指定方法

erasedParamTypes : 擦除对象类型

targetParamTypes : 目标转换类型

---------------------------------计数器-------------------------------------------

@InvalidateAssignCache  :在给的计算器上加1. 如果不存在则初始化为1

@DecrementCounterInCache : 在给的计数器上减1

@ReadCounterFromCache  :读取计数器

@UpdateCounterFromCache : 更新计数器

Simple-Spring-Memcached代码阅读之BridgeMethod

http://www.colorfuldays.org/program/java/bridgemethod%E7%9A%84%E4%BD%9C%E7%94%A8/

http://www.colorfuldays.org/tag/ssm/   这个系列不错

@Autowired private Cache appCache;

appCache.set(Constants.CACHE_KEY + members.getMemberId(), 3600,cacheValue);

simple-spring-memcached简介
http://blog.csdn.net/javaman_chen/article/details/7682290

http://blog.csdn.net/a9529lty/article/details/8529421

学习了memcache，这是个好东西，分享一下自己的小实例，也方便以后查找使用

一、前期准备

1)  下载memcached服务端memcached-1.2.6-win32-bin.zip，地址：http://code.jellycan.com/memcached/

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:oxm="http://www.springframework.org/schema/oxm"
    xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd  
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd  
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
       http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.1.xsd">

    <bean id="memcachedPool" class="com.danga.MemCached.SockIOPool"
        factory-method="getInstance" init-method="initialize" destroy-method="shutDown">
        <constructor-arg>
            <value>neeaMemcachedPool</value>
        </constructor-arg>
        <property name="servers">
            <list>
                <value>127.0.0.1:11211</value>
            </list>
        </property>
        <property name="initConn">
            <value>20</value>
        </property>
        <property name="minConn">
            <value>10</value>
        </property>
        <property name="maxConn">
            <value>50</value>
        </property>
        <property name="maintSleep">
            <value>3000</value>
        </property>
        <property name="nagle">
            <value>false</value>
        </property>
        <property name="socketTO">
            <value>3000</value>
        </property>
    </bean>
    
    <bean id="memcachedClient" class="com.danga.MemCached.MemCachedClient">
        <constructor-arg>
            <value>neeaMemcachedPool</value>
        </constructor-arg>
    </bean>
    

</beans>

package com.abin.lee.spring.memcache;

import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.danga.MemCached.MemCachedClient;

public class MemcacheUtilTest {
 static MemCachedClient memcachedClient;
 @BeforeClass
 public static void setUpBeforeClass() throws Exception {
  ApplicationContext context= new ClassPathXmlApplicationContext("com/abin/lee/spring/memcache/spring-memcache.xml");
  memcachedClient= (MemCachedClient)context.getBean("memcachedClient");
 }

 @Test
 public void test() {
  memcachedClient.set("name", "abin");
  System.out.println(memcachedClient.get("name"));
 }
}

     - 到http://code.jellycan.com/memcached/下载稳定版。

     - 下载后解压到某个盘下面，比如在c:\memcached，在终端（也即cmd命令界面）下输入 ‘c:\memcached\memcached.exe -d install’ 安装。

     - 再输入： ‘c:\memcached\memcached.exe -d start’ 启动。

     - 修改memcache的内存大小，可以在注册表里找到HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Services/memcached Server，修改ImagePath的值为
“C:/memcached/memcached.exe” -d runservice -m 512
  NOTE: Windows版本一般用作开发调试只用，不建议在产品环境中使用。

二：JAVA连接使用Memcached
  1, 下载memcached客户端开发包，地址https://github.com/gwhalin/Memcached-Java-Client
  2，下面是一个连接并使用的简单例子

package com.ea.online.memcache;

import java.util.Date;

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;

public class MyClass {

    // create a static client as most installs only need
    // a single instance
    protected static MemCachedClient mcc = new MemCachedClient();

    protected static SockIOPool pool = null;
    // set up connection pool once at class load
    static {

        // Server list
        String[] servers = { "localhost:11211" };

        // Specify memcached capacity
        Integer[] weights = { 3, 3, 2 };

        /*
         * String[] serverlist = { "cache0.server.com:12345",
         * "cache1.server.com:12345" }; Integer[] weights = { new
         * Integer(5), new Integer(2) }; int initialConnections = 10; int
         * minSpareConnections = 5; int maxSpareConnections = 50; long
         * maxIdleTime = 1000 * 60 * 30; // 30 minutes long maxBusyTime = 1000 *
         * 60 * 5; // 5 minutes long maintThreadSleep = 1000 * 5; // 5 seconds
         * int socketTimeOut = 1000 * 3; // 3 seconds to block on reads int
         * socketConnectTO = 1000 * 3; // 3 seconds to block on initial
         * connections. If 0, then will use blocking connect (default) boolean
         * failover = false; // turn off auto-failover in event of server down
         * boolean nagleAlg = false; // turn off Nagle's algorithm on all
         * sockets in pool boolean aliveCheck = false; // disable health check
         * of socket on checkout
         *
         * SockIOPool pool = SockIOPool.getInstance();
         * pool.setServers(serverlist);
         * pool.setWeights(weights);
         * pool.setInitConn(initialConnections);
         * pool.setMinConn(minSpareConnections);
         * pool.setMaxConn(maxSpareConnections); pool.setMaxIdle(maxIdleTime);
         * pool.setMaxBusyTime(maxBusyTime);
         * pool.setMaintSleep(maintThreadSleep);
         * pool.setSocketTO(socketTimeOut); pool.setNagle(nagleAlg);
         * pool.setHashingAlg(SockIOPool.NEW_COMPAT_HASH);
         * pool.setAliveCheck(true); pool.initialize();
         */

        // grab an instance of our connection pool
        pool = SockIOPool.getInstance();

        // set the servers and the weights
        pool.setServers(servers);
        pool.setWeights(weights);

        // Specify main thread maintain frequency
        pool.setMaintSleep(30);

        // set some TCP settings
        // disable nagle
        pool.setNagle(false);
        // set the read timeout to 3 secs
        pool.setSocketTO(3000);
        // and don't set a connect timeout
        pool.setSocketConnectTO(0);

        // initialize the connection pool
        pool.initialize();

    }

    // from here on down, you can call any of the client calls
    public static void main(String[] args) {
        // Test expired
        mcc.set("foo", "This is a test String", new Date(
                new Date().getTime() + 3000));
        String bar = mcc.get("foo").toString();
        System.out.println("test-->" + bar);
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(mcc.get("foo"));
        }
        // pool.shutDown();
    }
}

详细使用可以借鉴这篇文章：http://sillycat.iteye.com/blog/563615

三：结合AOP编程
  1，对于memcached与spring aop的集成网上又是一堆，这里不提了。
  2，对于memcached与guice aop的集成可参考http://code.google.com/p/google-guice/wiki/AOP
  3，对于需要通过手动实现动态代理的方式来实现AOP的可以参考 http://www.blogjava.net/DoubleJ/archive/2008/03/04/183796.html

四：一个简单的环绕通知切面，不可运行，仅作参考

public Around implements MethodInterceptor {
 ....
    public Object invoke(MethodInvocation mi, Object[] args) {
        Object obj = null;
        //从Memcached中获取
        obj = mcc.get(this.class.getName() + mi.getMethodName() + args.hashcode());
        if(obj != null) {
            return obj;
        }
      
        obj = method.invoke(args);
      
        //存入Memcached
        mcc.set(this.class.getName() + mi.getMethodName() + args.hashcode, obj, expiredDate);
        return obj;
    }
 ....
} 

南京-HF(226358522)  11:22:44
对
ζ 过了时的流行 ♬(779014475)  11:22:50
加mc 本来就是为了减少mysql操作的。。
ζ 过了时的流行 ♬(779014475)  11:22:54
这样子都没啥意义了。。
南京-HF(226358522)  11:23:07
应该是mysql里面有触发器，当数据有改变，就会同步到memcached
南京-HF(226358522)  11:23:30
就看你以哪个数据为主了
南京-HF(226358522)  11:24:04
这样memcached的目的就是加快你的查询速度
沧海长风(136419390)  11:24:18
这方案根据自己需求设定
沧海长风(136419390)  11:24:23
组合很多吧
ζ 过了时的流行 ♬(779014475)  11:25:03
最近也碰到。。mysql与mc同步的。。不知道有啥好方案
南京-HF(226358522)  11:25:08
毕竟，查询用的是最多的。修改或者插入的话，数据库的数据必须得边，所以才有这么个方案。当然这个也不一定适合你们的场景，你自己取舍
南京-HF(226358522)  11:26:21
如果你的数据，增删改查都很频繁那这种就不适合了
ζ 过了时的流行 ♬(779014475)  11:26:54
恩。。这样的话读写都直接对mc操作。。然后定时同步。。
ζ 过了时的流行 ♬(779014475)  11:27:09
但是蛋疼的就是同步方案。。

ζ 过了时的流行 ♬(779014475)  11:27:25
不好做增量同步。。
沧海长风(136419390)  11:27:31
有时做些冗余是不错的
ζ 过了时的流行 ♬(779014475)  11:27:36
服务端用c写的。