堆栈和堆的内容在定位问题的时候，都是非常重要的信息。线程堆栈 dump 可以了解当时 JVM 中所有线程的运行情况，比如线程的状态和当前正在运行的代码行。堆 dump 可以了解当时堆的使用情况，各个类实例的数量及各个实例所占用的空间大小。

线程堆栈

使用 jstack

jstack 是 JDK 自带的工具，用于 dump 指定进程 ID(PID)的 JVM 的线程堆栈信息。

# 打印堆栈信息到标准输出 jstack PID  
# 打印堆栈信息到标准输出，会打印关于锁的信息 jstack -l PID  
强制打印堆栈信息到标准输出，如果使用 jstack PID 没有响应的情况下(此时 JVM 进程可能挂起)，
加 -F 参数 jstack -F PID 

使用 jcmd

jcmd 是 JDK 自带的工具，用于向 JVM 进程发送命令，根据命令的不同，可以代替或部分代替 jstack、jmap 等。可以发送命令 Thread.print 来打印出 JVM 的线程堆栈信息。

# 下面的命令同等于 jstack PID 
jcmd PID Thread.print  

# 同等于 jstack -l PID 
jcmd PID Thread.print -l 

使用 kill -3

kill 可以向特定的进程发送信号(SIGNAL)，缺省情况是发送终止(TERM) 的信号 ，即 kill PID 与 kill -15 PID 或 kill -TERM PID 是等价的。JVM 进程会监听 QUIT 信号(其值为 3)，当收到这个信号时，会打印出当时的线程堆栈和堆内存使用概要，相比 jstack，此时多了堆内存的使用概要情况。但 jstack 可以指定 -l 参数，打印锁的信息。

kill -3 PID 
# 或 kill -QUIT PID 

堆

-XX:+HeapDumpOnOutOfMemoryError

添加 JVM 参数 -XX:+HeapDumpOnOutOfMemoryError 后，当发生 OOM(OutOfMemory)时，自动堆 dump。缺省情况下，JVM 会创建一个名称为 java_pidPID.hprof 的堆 dump 文件在 JVM 的工作目录下。但可以使用参数 -XX:HeapDumpPath=PATH 来指定 dump 文件的保存位置。

# JVM 发生 OOM 时，会自动在 /var/log/abc 目录下产生堆 dump 文件 java_pidPID.hprof 
java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/var/log/abc/ 

jmap

jmap 也是 JDK 自带的工具，主要用于获取堆相关的信息。

堆 dump

# 将 JVM 的堆 dump 到指定文件，如果堆中对象较多，需要的时间会较长，子参数 format 只支持 b，
即二进制格式
jmap -dump:format=b,file=FILE_WITH_PATH

# 如果 JVM 进程未响应命令，可以加上参数 -F 尝试
jmap -F -dump:format=b,file=FILE_WITH_PATH

# 可以只 dump 堆中的存活对象，加上 live 子参数，但使用 -F 时不支持 live
jmap -dump:live,format=b,file=FILE_WITH_PATH

获取堆概要信息

# -heap 参数用于查看指定 JVM 进程的堆的信息，包括堆的各个参数的值，堆中新生代、年老代的内存大小、使用率等 
jmap -heap PID  

# 同样，如果 JVM 进程未响应命令，可以加上参数 -F 尝试 
jmap -F -heap PID 

一个实例输出如下：

Attaching to process ID 68322, please wait
Debugger attached successfully.
Server compiler detected.
JVM version is 25.112-b16

using thread-local object allocation.
Parallel GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 268435456 (256.0MB)
   NewSize                  = 8388608 (8.0MB)
   MaxNewSize               = 89128960 (85.0MB)
   OldSize                  = 16777216 (16.0MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

Heap Usage:
PS Young Generation
Eden Space:
   capacity = 41943040 (40.0MB)
   used     = 1701504 (1.6226806640625MB)
   free     = 40241536 (38.3773193359375MB)
   4.05670166015625% used
From Space:
   capacity = 4194304 (4.0MB)
   used     = 0 (0.0MB)
   free     = 4194304 (4.0MB)
   0.0% used
To Space:
   capacity = 5242880 (5.0MB)
   used     = 0 (0.0MB)
   free     = 5242880 (5.0MB)
   0.0% used
PS Old Generation
   capacity = 30408704 (29.0MB)
   used     = 12129856 (11.56793212890625MB)
   free     = 18278848 (17.43206787109375MB)
   39.889421134159484% used

16658 interned Strings occupying 1428472 bytes.

获取堆中的类实例统计

# 打印 JVM 堆中的类实例统计信息，以占用内存的大小排序，同样，如果 JVM 未响应命令，也可以使用 -F 参数 
jmap -histo PID  

# 也可以只统计堆中的存活对象，加上 live 子参数，但使用 -F 时不支持 live 
jmap -histo:live PID 

使用 jcmd

# 等同 jmap -dump:live,format=b,file=FILE_WITH_PATH
jcmd PID GC.heap_dump FILE_WITH_PATH

# 等同 jmap -dump:format=b,file=FILE_WITH_PATH
jcmd PID GC.heap_dump -all FILE_WITH_PATH

# 等同 jmap -histo:live PID
jcmd PID GC.class_histogram

# 等同 jmap -histo PID
jcmd PID GC.class_histogram -all

1. 最快的web服务器
2. 最快的并发框架
3. 最快的RPC服务器
4. 最快的websocket框架
5. 最快的RESTful框架
6. 最快的Go序列化框架
7. 最快的Go web框架
8. 最快的Java序列化框架

1. pom.xml中加入依赖包
   
           <dependency>
               <groupId>com.google.guava</groupId>
               <artifactId>guava</artifactId>
               <version>18.0</version>
           </dependency>
   
   
2. 改造CacheManager，MyConcurrentMapCacheManager
   
   package com.paul.common.cache;
   /*
    * Copyright 2002-2014 the original author or authors.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   
   import java.util.Collection;
   import java.util.Collections;
   import java.util.Map;
   import java.util.concurrent.ConcurrentHashMap;
   import java.util.concurrent.ConcurrentMap;
   import java.util.concurrent.TimeUnit;
   
   import org.springframework.cache.Cache;
   import org.springframework.cache.CacheManager;
   import org.springframework.cache.concurrent.ConcurrentMapCache;
   
   import com.google.common.cache.CacheBuilder;
   
   /**
    * {@link CacheManager} implementation that lazily builds {@link ConcurrentMapCache}
    * instances for each {@link #getCache} request. Also supports a 'static' mode where
    * the set of cache names is pre-defined through {@link #setCacheNames}, with no
    * dynamic creation of further cache regions at runtime.
    *
    * <p>Note: This is by no means a sophisticated CacheManager; it comes with no
    * cache configuration options. However, it may be useful for testing or simple
    * caching scenarios. For advanced local caching needs, consider
    * {@link org.springframework.cache.guava.GuavaCacheManager} or
    * {@link org.springframework.cache.ehcache.EhCacheCacheManager}.
    *
    * @author Juergen Hoeller
    * @since 3.1
    * @see ConcurrentMapCache
    */
   public class MyConcurrentMapCacheManager implements CacheManager {
   
       private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<String, Cache>(16);
   
       private boolean dynamic = true;
   
       private boolean allowNullValues = true;
       
       private long expireTime = 30;
       
       private long maximumSize = 100;
   
   
       /**
        * Construct a dynamic ConcurrentMapCacheManager,
        * lazily creating cache instances as they are being requested.
        */
       public MyConcurrentMapCacheManager() {
       }
   
       /**
        * Construct a static ConcurrentMapCacheManager,
        * managing caches for the specified cache names only.
        */
       public MyConcurrentMapCacheManager(long expireTime, long maximumSize) {
           if(expireTime > 0)
               this.expireTime = expireTime;
           if(maximumSize > 0)
               this.maximumSize = maximumSize;
       }
   
   
       /**
        * Specify the set of cache names for this CacheManager's 'static' mode.
        * <p>The number of caches and their names will be fixed after a call to this method,
        * with no creation of further cache regions at runtime.
        * <p>Calling this with a {@code null} collection argument resets the
        * mode to 'dynamic', allowing for further creation of caches again.
        */
       public void setCacheNames(Collection<String> cacheNames) {
           if (cacheNames != null) {
               for (String name : cacheNames) {
                   this.cacheMap.put(name, createConcurrentMapCache(name));
               }
               this.dynamic = false;
           }
           else {
               this.dynamic = true;
           }
       }
   
       /**
        * Specify whether to accept and convert {@code null} values for all caches
        * in this cache manager.
        * <p>Default is "true", despite ConcurrentHashMap itself not supporting {@code null}
        * values. An internal holder object will be used to store user-level {@code null}s.
        * <p>Note: A change of the null-value setting will reset all existing caches,
        * if any, to reconfigure them with the new null-value requirement.
        */
       public void setAllowNullValues(boolean allowNullValues) {
           if (allowNullValues != this.allowNullValues) {
               this.allowNullValues = allowNullValues;
               // Need to recreate all Cache instances with the new null-value configuration
               for (Map.Entry<String, Cache> entry : this.cacheMap.entrySet()) {
                   entry.setValue(createConcurrentMapCache(entry.getKey()));
               }
           }
       }
   
       /**
        * Return whether this cache manager accepts and converts {@code null} values
        * for all of its caches.
        */
       public boolean isAllowNullValues() {
           return this.allowNullValues;
       }
   
   
       @Override
       public Collection<String> getCacheNames() {
           return Collections.unmodifiableSet(this.cacheMap.keySet());
       }
   
       @Override
       public Cache getCache(String name) {
           Cache cache = this.cacheMap.get(name);
           if (cache == null && this.dynamic) {
               synchronized (this.cacheMap) {
                   cache = this.cacheMap.get(name);
                   if (cache == null) {
                       cache = createConcurrentMapCache(name);
                       this.cacheMap.put(name, cache);
                   }
               }
           }
           return cache;
       }
   
       /**
        * Create a new ConcurrentMapCache instance for the specified cache name.
        * @param name the name of the cache
        * @return the ConcurrentMapCache (or a decorator thereof)
        */
       protected Cache createConcurrentMapCache(String name) {
           //return new ConcurrentMapCache(name, isAllowNullValues());
           //此处改用GOOGLE GUAVA的构造MANAGER方式
           return new ConcurrentMapCache(name,
                                           CacheBuilder.newBuilder()
                                                       .expireAfterWrite(this.expireTime, TimeUnit.MINUTES)
                                                       .maximumSize(this.maximumSize)
                                                       .build()
                                                       .asMap(), 
                                           isAllowNullValues());
       }
   
   }
   
   
   
3. 配置想着bean, cache-concurrentmap-applicationcontext.xml
   
   <?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:context="http://www.springframework.org/schema/context"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context-3.0.xsd
             http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
             http://www.springframework.org/schema/cache
             http://www.springframework.org/schema/cache/spring-cache.xsd
             http://www.springframework.org/schema/jee 
             http://www.springframework.org/schema/jee/spring-jee.xsd
             http://www.springframework.org/schema/util
             http://www.springframework.org/schema/util/spring-util.xsd">
   
       <cache:annotation-driven />
   
       <!-- <bean id="cacheManager"
           class="org.springframework.cache.concurrent.ConcurrentMapCacheManager" >
           <property name="cacheNames">
               <list>
                   <value>my-local-cache</value>
               </list>
           </property>
       </bean> -->
       
       <bean id="cacheManager"
           class="com.paul.common.cache.MyConcurrentMapCacheManager">
           <constructor-arg index="0" value="1" />
           <constructor-arg index="1" value="5000" />
       </bean>    
       
   </beans>
   
   
   
4. 通过注释进行使用
   
   /*
    * JBoss, Home of Professional Open Source
    * Copyright 2014, Red Hat, Inc. and/or its affiliates, and individual
    * contributors by the @authors tag. See the copyright.txt in the
    * distribution for a full listing of individual contributors.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    * http://www.apache.org/licenses/LICENSE-2.0
    * Unless required by applicable law or agreed to in writing, software
    * distributed under the License is distributed on an "AS IS" BASIS,
    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    * See the License for the specific language governing permissions and
    * limitations under the License.
    */
   package com.paul.springmvc.data;
   
   import java.util.List;
   
   import javax.persistence.EntityManager;
   import javax.persistence.criteria.CriteriaBuilder;
   import javax.persistence.criteria.CriteriaQuery;
   import javax.persistence.criteria.Root;
   
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.cache.annotation.CacheEvict;
   import org.springframework.cache.annotation.Cacheable;
   import org.springframework.stereotype.Repository;
   import org.springframework.transaction.annotation.Transactional;
   
   import com.paul.springmvc.model.Member;
   
   @Repository
   @Transactional
   public class MemberDaoImpl implements MemberDao {
       @Autowired
       private EntityManager em;
   
       @Cacheable(value = "my-local-cache", key = "#id")
       public Member findById(Long id) {
           System.out.println("MemberDaoImpl NO CACHE");
           return em.find(Member.class, id);
       }
   
       public Member findByEmail(String email) {
           CriteriaBuilder cb = em.getCriteriaBuilder();
           CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
           Root<Member> member = criteria.from(Member.class);
   
           /*
            * Swap criteria statements if you would like to try out type-safe criteria queries, a new
            * feature in JPA 2.0 criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
            */
   
           criteria.select(member).where(cb.equal(member.get("email"), email));
           return em.createQuery(criteria).getSingleResult();
       }
   
       public List<Member> findAllOrderedByName() {
           CriteriaBuilder cb = em.getCriteriaBuilder();
           CriteriaQuery<Member> criteria = cb.createQuery(Member.class);
           Root<Member> member = criteria.from(Member.class);
   
           /*
            * Swap criteria statements if you would like to try out type-safe criteria queries, a new
            * feature in JPA 2.0 criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
            */
   
           criteria.select(member).orderBy(cb.asc(member.get("name")));
           return em.createQuery(criteria).getResultList();
       }
   
       @CacheEvict(value="my-local-cache",allEntries=true,beforeInvocation=true)//清空所有缓存
       public void register(Member member) {
           em.persist(member);
           return;
       }
   }

Spring Cache抽象详解

在CDI BEAN中使用CACHE

package com.paul.myejb;

import javax.annotation.Resource;
import javax.cache.annotation.CacheResult;
import javax.ejb.Remote;
import javax.ejb.Stateless;
import javax.interceptor.Interceptors;

import org.infinispan.Cache;
import org.infinispan.manager.EmbeddedCacheManager;
//import org.springframework.cache.annotation.Cacheable;
import org.springframework.ejb.interceptor.SpringBeanAutowiringInterceptor;

/**
 * Session Bean implementation class HelloWorldBean
 */
@Stateless
//@Local(HelloWorld.class)
@Remote(HelloWorld.class)
@Interceptors(SpringBeanAutowiringInterceptor.class)
//@RolesAllowed({Roles.ADMIN})
public class HelloWorldBean implements HelloWorld {
    
    @Resource(lookup = "java:jboss/infinispan/tickets")
    private EmbeddedCacheManager container;
    
    
    /**
     * Default constructor. 
     */
    public HelloWorldBean() {
    }

//    @Transactional
//    @Cacheable(value = "books", key = "#name")
    @CacheResult
    public String sayHello(String name) {
        System.out.println("NO CACHE");
        String result = "Hello " + name + ", I am HelloWorldBean.";
        Cache<String, String> cache = this.container.getCache();
        cache.put(name, result);
        return result;
    }

}

1. 添加依赖的SPRING BEAN
   
   <?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:context="http://www.springframework.org/schema/context"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:jee="http://www.springframework.org/schema/jee"
       xsi:schemaLocation="http://www.springframework.org/schema/context
             http://www.springframework.org/schema/context/spring-context-3.0.xsd
             http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
             http://www.springframework.org/schema/cache
             http://www.springframework.org/schema/cache/spring-cache.xsd
             http://www.springframework.org/schema/jee 
             http://www.springframework.org/schema/jee/spring-jee.xsd">
   
       <cache:annotation-driven />
       
       <bean id="cacheManager"
             class="org.infinispan.spring.provider.ContainerCacheManagerFactoryBean">
             <constructor-arg ref="cacheContainer"  />
       </bean>
       
       <jee:jndi-lookup id="cacheContainer" jndi-name="java:jboss/infinispan/tickets" > 
       </jee:jndi-lookup>
       
       <!-- <bean id="cacheContainer"
             class="com.paul.myejb.common.util.cache.JndiSpringCacheManagerFactoryBean"
             p:infinispanJNDI="java:jboss/infinispan/tickets" /> -->
       
   </beans>
   
   
2. 使用CACHE
   
   package com.paul.myejb.spring;
   
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.cache.CacheManager;
   import org.springframework.cache.annotation.Cacheable;
   import org.springframework.stereotype.Component;
   
   @Component
   public class MySpringBean {
       
       @Autowired
       private CacheManager cacheManager;
       
       @Cacheable(value = "my-local-cache", key = "#name")
       public String sayHello(String name)
       {
           System.out.println("MySpringBean NO CACHE");
           String result = "Hi " + name + ", I am Spring!";
           org.springframework.cache.Cache springCache = this.cacheManager.getCache("my-local-cache");
           System.out.println(springCache.get(name) == null ? "null" : springCache.get(name).get());
           springCache.put(name, result);
           return result;
       }
   
   }
   
   
3. 
   

infinispan-quickstart

• autoConnectRetry simply means the driver will automatically attempt to reconnect to the server(s) after unexpected disconnects. In production environments you usually want this set to true.

• connectionsPerHost are the amount of physical connections a single Mongo instance (it's singleton so you usually have one per application) can establish to a mongod/mongos process. At time of writing the java driver will establish this amount of connections eventually even if the actual query throughput is low (in order words you will see the "conn" statistic in mongostat rise until it hits this number per app server).

  There is no need to set this higher than 100 in most cases but this setting is one of those "test it and see" things. Do note that you will have to make sure you set this low enough so that the total amount of connections to your server do not exceed

  db.serverStatus().connections.available

  In production we currently have this at 40.

• connectTimeout. As the name suggest number of milliseconds the driver will wait before a connection attempt is aborted. Set timeout to something long (15-30 seconds) unless there's a realistic, expected chance this will be in the way of otherwise succesful connection attempts. Normally if a connection attempt takes longer than a couple of seconds your network infrastructure isn't capable of high throughput.

• maxWaitTime. Number of ms a thread will wait for a connection to become available on the connection pool, and raises an exception if this does not happen in time. Keep default.

• socketTimeout. Standard socket timeout value. Set to 60 seconds (60000).

• threadsAllowedToBlockForConnectionMultiplier. Multiplier for connectionsPerHost that denotes the number of threads that are allowed to wait for connections to become available if the pool is currently exhausted. This is the setting that will cause the "com.mongodb.DBPortPool$SemaphoresOut: Out of semaphores to get db connection" exception. It will throw this exception once this thread queue exceeds the threadsAllowedToBlockForConnectionMultiplier value. For example, if the connectionsPerHost is 10 and this value is 5 up to 50 threads can block before the aforementioned exception is thrown.

  If you expect big peaks in throughput that could cause large queues temporarily increase this value. We have it at 1500 at the moment for exactly that reason. If your query load consistently outpaces the server you should just improve your hardware/scaling situation accordingly.

• readPreference. (UPDATED, 2.8+) Used to determine the default read preference and replaces "slaveOk". Set up a ReadPreference through one of the class factory method. A full description of the most common settings can be found at the end of this post

• w. (UPDATED, 2.6+) This value determines the "safety" of the write. When this value is -1 the write will not report any errors regardless of network or database errors. WriteConcern.NONE is the appropriate predefined WriteConcern for this. If w is 0 then network errors will make the write fail but mongo errors will not. This is typically referred to as "fire and forget" writes and should be used when performance is more important than consistency and durability. Use WriteConcern.NORMAL for this mode.

  If you set w to 1 or higher the write is considered safe. Safe writes perform the write and follow it up by a request to the server to make sure the write succeeded or retrieve an error value if it did not (in other words, it sends a getLastError() command after you write). Note that until this getLastError() command is completed the connection is reserved. As a result of that and the additional command the throughput will be signficantly lower than writes with w <= 0. With a w value of exactly 1 MongoDB guarantees the write succeeded (or verifiably failed) on the instance you sent the write to.

  In the case of replica sets you can use higher values for w whcih tell MongoDB to send the write to at least "w" members of the replica set before returning (or more accurately, wait for the replication of your write to "w" members). You can also set w to the string "majority" which tells MongoDB to perform the write to the majority of replica set members (WriteConcern.MAJORITY). Typicall you should set this to 1 unless you need raw performance (-1 or 0) or replicated writes (>1). Values higher than 1 have a considerable impact on write throughput.

• fsync. Durability option that forces mongo to flush to disk after each write when enabled. I've never had any durability issues related to a write backlog so we have this on false (the default) in production.

• j *(NEW 2.7+)*. Boolean that when set to true forces MongoDB to wait for a successful journaling group commit before returning. If you have journaling enabled you can enable this for additional durability. Refer to http://www.mongodb.org/display/DOCS/Journaling to see what journaling gets you (and thus why you might want to enable this flag).

ReadPreference The ReadPreference class allows you to configure to what mongod instances queries are routed if you are working with replica sets. The following options are available :

• ReadPreference.primary() : All reads go to the repset primary member only. Use this if you require all queries to return consistent (the most recently written) data. This is the default.

• ReadPreference.primaryPreferred() : All reads go to the repset primary member if possible but may query secondary members if the primary node is not available. As such if the primary becomes unavailable reads become eventually consistent, but only if the primary is unavailable.

• ReadPreference.secondary() : All reads go to secondary repset members and the primary member is used for writes only. Use this only if you can live with eventually consistent reads. Additional repset members can be used to scale up read performance although there are limits to the amount of (voting) members a repset can have.

• ReadPreference.secondaryPreferred() : All reads go to secondary repset members if any of them are available. The primary member is used exclusively for writes unless all secondary members become unavailable. Other than the fallback to the primary member for reads this is the same as ReadPreference.secondary().

• ReadPreference.nearest() : Reads go to the nearest repset member available to the database client. Use only if eventually consistent reads are acceptable. The nearest member is the member with the lowest latency between the client and the various repset members. Since busy members will eventually have higher latencies this should also automatically balance read load although in my experience secondary(Preferred) seems to do so better if member latencies are relatively consistent.

Note : All of the above have tag enabled versions of the same method which return TaggableReadPreference instances instead. A full description of replica set tags can be found here :Replica Set Tags

Codis 由四部分组成:

• Codis Proxy   (codis-proxy)

• Codis Manager (codis-config)

• Codis Redis   (codis-server)

• ZooKeeper

codis-proxy 是客户端连接的 Redis 代理服务, codis-proxy 本身实现了 Redis 协议, 表现得和一个原生的 Redis 没什么区别 (就像 Twemproxy), 对于一个业务来说, 可以部署多个 codis-proxy, codis-proxy 本身是无状态的.

codis-config 是 Codis 的管理工具, 支持包括, 添加/删除 Redis 节点, 添加/删除 Proxy 节点, 发起数据迁移等操作. codis-config 本身还自带了一个 http server, 会启动一个 dashboard, 用户可以直接在浏览器上观察 Codis 集群的运行状态.

codis-server 是 Codis 项目维护的一个 Redis 分支, 基于 2.8.13 开发, 加入了 slot 的支持和原子的数据迁移指令. Codis 上层的 codis-proxy 和 codis-config 只能和这个版本的 Redis 交互才能正常运行.

Codis 依赖 ZooKeeper 来存放数据路由表和 codis-proxy 节点的元信息, codis-config 发起的命令都会通过 ZooKeeper 同步到各个存活的 codis-proxy.

Codis 支持按照 Namespace 区分不同的产品, 拥有不同的 product name 的产品, 各项配置都不会冲突.

目前 Codis 已经是稳定阶段，目前豌豆荚已经在使用该系统。

架构：

特性：

• 自动平衡

• 使用非常简单

• 图形化的面板和管理工具

• 支持绝大多数 Redis 命令，完全兼容 twemproxy

• 支持 Redis 原生客户端

• 安全而且透明的数据移植，可根据需要轻松添加和删除节点

• 提供命令行接口

• RESTful APIs

安装：

• Install go

• go get github.com/wandoulabs/codis

• cd codis

• ./bootstrap.sh

• make gotest

• cd sample

• follow instructions in usage.md

界面截图：

Dashboard

Migrate

Slots

吞吐量 VS 暂停时间

HotSpot虚拟机上的垃圾收集

-XX:+UseSerialGC

-XX:+UseParallelGC

-XX:+UseParallelOldGC

-XX:ParallelGCThreads

-XX:-UseAdaptiveSizePolicy

-XX:GCTimeRatio

-XX:MaxGCPauseMillis