[无名弟子]姚远|2017年09月17日的日报-技能树.IT修真院

发表于： 2017-09-17 22:26:41

1 679

今天完成的事情：

Memcached是danga.com开发的一套分布式内存对象缓存系统，用于在动态系统中减少数据库负载，提升性能。

Memcached有两个核心组件组成：服务端（ms）和客户端（mc）。首先mc拿到ms列表，并对key做hash转化，根据hash值确定kv对所存的ms位置。然后在一个memcached的查询中，mc先通过计算key的hash值来确定kv对所处在的ms位置。当ms确定后，客户端就会发送一个查询请求给对应的ms，让它来查找确切的数据。因为ms之间并没有护卫备份，也就不需要互相通信，所以效率较高。

适用场合

1.分布式应用。由于memcached本身基于分布式的系统，所以尤其适合大型的分布式系统。

2.数据库前段缓存。数据库常常是网站系统的瓶颈。数据库的大并发量访问，常常造成网站内存溢出。当然我们也可以使用Hibernate的缓存机制。但memcached是基于分布式的，并可独立于网站应用本身，所以更适合大型网站进行应用的拆分。
3.服务器间数据共享。举例来讲，我们将网站的登录系统、查询系统拆分为两个应用，放在不同的服务器上，并进行集群，那这个时候用户登录后，登录信息如何从登录系统服务器同步到查询系统服务器呢？这时候，我们便可以使用memcached，登录系统将登录信息缓存起来，查询系统便可以获得登录信息，就像获取本地信息一样。
因为 mc所使用的hash算法，并不会考虑到每个ms的内存大小。理论上mc会分配概率上等量的kv对给每个ms，这样如果每个ms的内存都不太一样，那可能会导致内存使用率的降低。所以一种替代的解决方案是，根据每个ms的内存大小，找出他们的最大公约数，然后在每个ms上开n个容量=最大公约数的 instance，这样就等于拥有了多个容量大小一样的子ms，从而提供整体的内存使用率。
内存分配

默认情况下，ms是用一个内置的叫“块分配器”的组件来分配内存的。舍弃c++标准的malloc/free的内存分配，而采用块分配器的主要目的是为了避免内存碎片，否则操作系统要花费更多时间来查找这些逻辑上连续的内存块（实际上是断开的）。用了块分配器，ms会轮流的对内存进行大块的分配，并不断重用。当然由于块的大小各不相同，当数据大小和块大小不太相符的情况下，还是有可能导致内存的浪费。

同时，ms对key和data都有相应的限制，key的长度不能超过250字节，data也不能超过块大小的限制 --- 1MB。

缓存策略

当ms的hash表满了之后，新的插入数据会替代老的数据，更新的策略是LRU（最近最少使用），以及每个kv对的有效时限。Kv对存储有效时限是在mc端由app设置并作为参数传给ms的。

同时ms采用是偷懒替代法，ms不会开额外的进程来实时监测过时的kv对并删除，而是当且仅当，新来一个插入的数据，而此时又没有多余的空间放了，才会进行清除动作。

Memcached工具类

直接copy了一手

@Component
@Repository
public class MemcachedUtils {
    private static final Logger log = Logger.getLogger(MemcachedUtils.class);
    private static MemCachedClient cachedClient;
    static {
        if(cachedClient == null)
            cachedClient = new MemCachedClient();
    }
    private MemcachedUtils(){}

    /**
     * 向缓存添加新的键值对，如果已经存在，则之前的值将被替换
     * @param key
     * @param value
     * @return
     */
    public static boolean set(String key,Object value){
        log.info("------->set方法+1");
        return setExp(key,value,null);
    }

    /**
     * 向缓存添加新的键值对，如果键已存在，则之前的值将被替换
     * @param key 键
     * @param value 值
     * @param expire 过期时间 new Date（1000*10）：十秒后过期
     * @return
     */
    public static boolean set(String key,Object value,Date expire){
        log.info("------->set方法+2");
        return setExp(key,value,expire);
    }

    /**
     * 向缓存添加新的键值对，如果键已经存在，则之前的值将被替换
     * @param key 键
     * @param value 值
     * @param expire 过期时间 new Date(1000*10):十秒后过期
     * @return
     */
    private static boolean setExp(String key,Object value,Date expire){
        boolean flag = false;
        try {
            flag = cachedClient.set(key,value,expire);
        }catch (Exception e){
            //记录Memcached日志
            MemcachedLog.writeLog("Mencached set 方法报错，key值："+key+"\r\n"+exceptionWrite(e));
        }
        return flag;
    }

    /**
     * 仅当缓存中不存在键时，add 命令才会向缓存中添加一个键值对
     * @param key 键
     * @param value 值
     * @return
     */
    public static boolean add(String key,Object value){
        return addExp(key,value,null);
    }

    /**
     * 仅当缓存中不存在键时，add命令才会向缓存中添加一个键值对
     * @param key 键
     * @param value 值
     * @param expire 过期时间 new Date（1000*10）：十秒过期
     * @return
     */
    public static boolean add(String key,Object value,Date expire){
        return addExp(key,value,expire);
    }

    /**
     * 仅当缓存中不存在键时，add命令才会向缓存中添加一个键值对
     * @param key 键
     * @param value 值
     * @param expire 过期时间 new Date（1000*10）：十秒过期
     * @return
     */
    private  static boolean addExp(String key,Object value,Date expire){
        boolean flag = false;
        try{
            flag = cachedClient.add(key, value, expire);
        }catch (Exception e){
            //记录Memcached 日志
            MemcachedLog.writeLog("Memcached add方法报错，key值："+key+"\r\n"+exceptionWrite(e));
        }
        return flag;
    }

    /**
     * 仅当键已存在时，replace命令才会替换缓存中的键
     * @param key 键
     * @param value 值
     * @return
     */
    public static boolean replace(String key,Object value){
        return replaceExp(key,value,null);
    }

    /**
     * 仅当键已经存在时，replace命令才会替换缓存中的键
     * @param key 键
     * @param value 值
     * @param expire 过期时间 new Date（1000*10）：十秒后过期
     * @return
     */
     public static boolean replace(String key,Object value, Date expire){
        return replaceExp(key,value,expire);
     }

    /**
     * 仅当键已经存在时，replace命令才会替换缓存中的键
     * @param key 键
     * @param value 值
     * @param expire 过期时间 new Date（1000*10）：十秒后过期
     * @return
     */
     private static boolean replaceExp(String key,Object value,Date expire){
         boolean flag = false;
         try {
             flag = cachedClient.replace(key,value,expire);
         }catch (Exception e){
             MemcachedLog.writeLog("Memcached replace方法报错，key值：" + key + "\r\n" + exceptionWrite(e));
         }
         return flag;
     }

    /**
     * get 命令用于检索与之前添加的键值对相关的值
     * @param key 键
     * @return
     */
     public static Object get(String key){
         Object obj = null;
         try {
             obj=cachedClient.get(key);
         }catch (Exception e){
             MemcachedLog.writeLog("Memcached get方法报错，key值：" + key + "\r\n" + exceptionWrite(e));
         }
         return obj;
     }

    /**
     *  删除 memcached中的任何现有值
     * @param key 键
     * @return
     */
      public static boolean delete(String key){
         return deleteExp(key,null);
      }

    /**
     * 删除memcached中的任何现有值
     * @param key 键
     * @param expire 过期时间 new Date(1000*10): 十秒后过期
     * @return
     */
      public  static boolean delete(String key,Date expire){
          return deleteExp(key,expire);
      }

    /**
     * 删除memcached中任何现有值，
     * @param key 键
     * @param expire 过期时间 new Date（1000*10）：十秒后过期
     * @return
     */
      private static boolean deleteExp(String key,Date expire){
          boolean flag= false;
          try {
              flag=cachedClient.delete(key,expire);
          }catch (Exception e){
              MemcachedLog.writeLog("Memcached delete方法报错，key值：" + key + "\r\n" + exceptionWrite(e));
          }
          return flag;
      }

    /**
     * 清理缓存中的所有键值对
     * @return
     */
      public static boolean flashAll(){
          boolean flag=false;
          try {
              flag=cachedClient.flushAll();
          }catch (Exception e){
              MemcachedLog.writeLog("Memcached flashAll方法报错\r\n" + exceptionWrite(e));
          }
          return flag;
      }

    /**
     * 返回异常栈信息，String类型
     * @param e
     * @return
     */
      private static String exceptionWrite(Exception e){
          StringWriter sw=new StringWriter();
          PrintWriter pw=new PrintWriter(sw);
          e.printStackTrace(pw);
          pw.flush();
          return sw.toString();
      }
      private static class MemcachedLog{
          private final static String MEMCACHED_LOG="D:\\memcache\\memcached.log";
          private final static String LINUX_MEMCACHED_LOG="/var/log/memcached/memcached.log";
          private static FileWriter fileWriter;
          private static BufferedWriter logWrite;
          //获取PID，可以找到对应的jvm进程
          private final static RuntimeMXBean runtime= ManagementFactory.getRuntimeMXBean();
          private final static String PID=runtime.getName();
          /**
           * 初始化写入流
           */
          static {
              try {
                  String osName = System.getProperty("os.name");
                  if(osName.indexOf("Window")==-1){
                      fileWriter=new FileWriter(MEMCACHED_LOG,true);
                  }else {
                      fileWriter=new FileWriter(LINUX_MEMCACHED_LOG,true);
                  }
                  logWrite=new BufferedWriter(fileWriter);
              }catch (IOException e){
                  log.error("memcached 日志初始化失败",e);
                  clossLogStream();
              }
          }
          /**
           * 写入日志信息
           * @param content 日志内容
           */
          public static void writeLog(String content){
              try {
                  logWrite.write("[" + PID + "] " + "- [" + (new Date().getTime()) + "]\r\n"
                          + content);
                  logWrite.newLine();
                  logWrite.flush();
              }catch (IOException e){
                  log.error("memcached 写入日志信息失败",e);
              }
          }
          /**
           * 关闭流
           */
          private static void clossLogStream(){
              try {
                  fileWriter.close();
                  logWrite.close();
              }catch (IOException e){
                  log.error("memcached 日志对象关闭失败",e);
              }
          }
      }
}