memcached-java客户端xmemcached使用总结 & 与Spring 集成

古城微笑少年丶 2022-06-10 08:48 139阅读 0赞

1. 最近调研了下memcached，之前2篇博客简单得介绍了用法，现在做个总结就当调研结束，本博客将从以下几个方面进行总结，

a. xmemcached简介

b. xmemcached的分布式

c. xmemcached支持的存储对象

d. xmemcached的容错性

e. xmemcached的性能[测试][Link 1]

由于memcached可以与[spring][]集成，所以本博客以和spring集成来讲以上几点

先来看看如何与spring集成，首先在pom中引入相应的包(spring相关的不列出来)

**\[plain\]**  view plain  copy

print ?

1.  <dependency>  
2.              <groupId>com.googlecode.xmemcached</groupId>  
3.              <artifactId>xmemcached</artifactId>  
4.              <version>2.0.0</version>  
5.          </dependency>

<dependency>
    			<groupId>com.googlecode.xmemcached</groupId>
    			<artifactId>xmemcached</artifactId>
    			<version>2.0.0</version>
    		</dependency>

以下是properties文件：

**\[plain\]**  view plain  copy

print ?

1.  \# the pool size(the number of client)  
2.  memcached.connectionPoolSize=50  
3.  \# in this mode, when a node out, it will throws MemcachedException when call this node  
4.  memcached.failureMode=true  
5.  \#server1    
6.  memcached.server1.host=192.168.88.140  
7.  memcached.server1.port=11211  
8.  memcached.server1.weight=1  
9.  \#server2    
10. memcached.server2.host=192.168.88.141  
11. memcached.server2.port=11211  
12. memcached.server2.weight=1  
13. \#server3    
14. memcached.server3.host=192.168.88.142  
15. memcached.server3.port=11211  
16. memcached.server3.weight=1

# the pool size(the number of client)
    memcached.connectionPoolSize=50
    # in this mode, when a node out, it will throws MemcachedException when call this node
    memcached.failureMode=true
    #server1  
    memcached.server1.host=192.168.88.140
    memcached.server1.port=11211
    memcached.server1.weight=1
    #server2  
    memcached.server2.host=192.168.88.141
    memcached.server2.port=11211
    memcached.server2.weight=1
    #server3  
    memcached.server3.host=192.168.88.142
    memcached.server3.port=11211
    memcached.server3.weight=1

spring bean配置：

**\[plain\]**  view plain  copy

print ?

1.  <?xml version="1.0" encoding="UTF-8"?>  
2.  <beans xmlns="http://www.springframework.org/schema/beans"  
3.      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
4.      xmlns:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c"  
5.      xmlns:rabbit="http://www.springframework.org/schema/rabbit" xmlns:task="http://www.springframework.org/schema/task"  
6.      xsi:schemaLocation="http://www.springframework.org/schema/beans   
7.                          http://www.springframework.org/schema/beans/spring-beans.xsd  
8.                          http://www.springframework.org/schema/context   
9.                          http://www.springframework.org/schema/context/spring-context.xsd  
10.                         http://www.springframework.org/schema/rabbit  
11.                         http://www.springframework.org/schema/rabbit/spring-rabbit-1.3.xsd  
12.                         http://www.springframework.org/schema/task  
13.                         http://www.springframework.org/schema/task/spring-task.xsd">  
14.   
15.     <bean id="memcachedClientBuilder" class="net.rubyeye.xmemcached.XMemcachedClientBuilder"  
16.         p:connectionPoolSize="$\{memcached.connectionPoolSize\}" p:failureMode="$\{memcached.failureMode\}">  
17.           
19.         <constructor-arg>  
20.             <list>  
21.                 <bean class="java.net.InetSocketAddress">  
22.                     <constructor-arg>  
23.                         <value>$\{memcached.server1.host\}</value>  
24.                     </constructor-arg>  
25.                     <constructor-arg>  
26.                         <value>$\{memcached.server1.port\}</value>  
27.                     </constructor-arg>  
28.                 </bean>  
29.                 <bean class="java.net.InetSocketAddress">  
30.                     <constructor-arg>  
31.                         <value>$\{memcached.server2.host\}</value>  
32.                     </constructor-arg>  
33.                     <constructor-arg>  
34.                         <value>$\{memcached.server2.port\}</value>  
35.                     </constructor-arg>  
36.                 </bean>  
37.                 <bean class="java.net.InetSocketAddress">  
38.                     <constructor-arg>  
39.                         <value>$\{memcached.server3.host\}</value>  
40.                     </constructor-arg>  
41.                     <constructor-arg>  
42.                         <value>$\{memcached.server3.port\}</value>  
43.                     </constructor-arg>  
44.                 </bean>  
45.             </list>  
46.         </constructor-arg>  
47.         <constructor-arg>  
48.             <list>  
49.                 <value>$\{memcached.server1.weight\}</value>  
50.                 <value>$\{memcached.server2.weight\}</value>  
51.                 <value>$\{memcached.server3.weight\}</value>  
52.             </list>  
53.         </constructor-arg>  
54.           
55.         <property name="commandFactory">  
56.             <bean class="net.rubyeye.xmemcached.command.BinaryCommandFactory" />  
57.         </property>  
58.         <property name="transcoder">  
59.             <bean class="net.rubyeye.xmemcached.transcoders.SerializingTranscoder" />  
60.         </property>  
61.         <property name="bufferAllocator">  
62.             <bean class="net.rubyeye.xmemcached.buffer.SimpleBufferAllocator"></bean>  
63.         </property>  
64.     </bean>  
65.       
66.     <bean id="memcachedClient" factory-bean="memcachedClientBuilder"  
67.         factory-method="build" destroy-method="shutdown" />  
68.   
69. </beans>

<?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:p="http://www.springframework.org/schema/p" xmlns:c="http://www.springframework.org/schema/c"
    	xmlns:rabbit="http://www.springframework.org/schema/rabbit" xmlns:task="http://www.springframework.org/schema/task"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans 
    	                    http://www.springframework.org/schema/beans/spring-beans.xsd
    		                http://www.springframework.org/schema/context 
    		                http://www.springframework.org/schema/context/spring-context.xsd
    		                http://www.springframework.org/schema/rabbit
                            http://www.springframework.org/schema/rabbit/spring-rabbit-1.3.xsd
    		                http://www.springframework.org/schema/task
                            http://www.springframework.org/schema/task/spring-task.xsd">
    
    	<bean id="memcachedClientBuilder" class="net.rubyeye.xmemcached.XMemcachedClientBuilder"
    		p:connectionPoolSize="${memcached.connectionPoolSize}" p:failureMode="${memcached.failureMode}">
    		
    		<constructor-arg>
    			<list>
    				<bean class="java.net.InetSocketAddress">
    					<constructor-arg>
    						<value>${memcached.server1.host}</value>
    					</constructor-arg>
    					<constructor-arg>
    						<value>${memcached.server1.port}</value>
    					</constructor-arg>
    				</bean>
    				<bean class="java.net.InetSocketAddress">
    					<constructor-arg>
    						<value>${memcached.server2.host}</value>
    					</constructor-arg>
    					<constructor-arg>
    						<value>${memcached.server2.port}</value>
    					</constructor-arg>
    				</bean>
    				<bean class="java.net.InetSocketAddress">
    					<constructor-arg>
    						<value>${memcached.server3.host}</value>
    					</constructor-arg>
    					<constructor-arg>
    						<value>${memcached.server3.port}</value>
    					</constructor-arg>
    				</bean>
    			</list>
    		</constructor-arg>
    		<constructor-arg>
    			<list>
    				<value>${memcached.server1.weight}</value>
    				<value>${memcached.server2.weight}</value>
    				<value>${memcached.server3.weight}</value>
    			</list>
    		</constructor-arg>
    		
    		<property name="commandFactory">
    			<bean class="net.rubyeye.xmemcached.command.BinaryCommandFactory" />
    		</property>
    		<property name="transcoder">
    			<bean class="net.rubyeye.xmemcached.transcoders.SerializingTranscoder" />
    		</property>
    		<property name="bufferAllocator">
    			<bean class="net.rubyeye.xmemcached.buffer.SimpleBufferAllocator"></bean>
    		</property>
    	</bean>
    	
    	<bean id="memcachedClient" factory-bean="memcachedClientBuilder"
    		factory-method="build" destroy-method="shutdown" />
    
    </beans>

这样就可以用memcachedClient了

举个简单的例子说明如何使用：

**\[java\]**  view plain  copy

print ?

1.  @Autowired  
2.      private MemcachedClient memcachedClient;  
3.    
4.      public Map<String, User> queryFromCache(List<String> keys) \{  
5.          Map<String, User> users = new HashMap<String, User>();  
6.          for (String key : keys) \{  
7.              try \{  
8.                  User user = memcachedClient.get(key);  
9.                  users.put(key, user);  
10.             \} catch (TimeoutException e) \{  
11.                 e.printStackTrace();  
12.             \} catch (InterruptedException e) \{  
13.                 e.printStackTrace();  
14.             \} catch (MemcachedException e) \{  
15.                 e.printStackTrace();  
16.             \}  
17.         \}  
18.         return users;  
19.     \}

@Autowired
    	private MemcachedClient memcachedClient;
    
    	public Map<String, User> queryFromCache(List<String> keys) {
    		Map<String, User> users = new HashMap<String, User>();
    		for (String key : keys) {
    			try {
    				User user = memcachedClient.get(key);
    				users.put(key, user);
    			} catch (TimeoutException e) {
    				e.printStackTrace();
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			} catch (MemcachedException e) {
    				e.printStackTrace();
    			}
    		}
    		return users;
    	}

# xmemcached简介 #

xmemcached是一个新[Java ][Java]memcached client。简单来说，Memcached 是一个高性能的分布式内存对象的key-value缓存系统，用于动态Web应用以减轻[数据库][Link 2]负载，现在也有很多人将它作为内存式数据库在使用，memcached通过它的自定义协议与客户端交互，而XMemcached就是它的一个[Java][]客户端实现。

Memcached的java客户端已经存在两个了：官方提供的基于传统阻塞io的客户端 、Dustin Sallings实现的基于[java ][Java]nio的spymemcached 。另外还有一些在此基础上的改进版本。

## XMemcached的主要特性 ##

## 高性能 ##

XMemcached同样是基于java nio的客户端，java nio相比于传统阻塞io模型来说，有效率高（特别在高并发下）和资源耗费相对较少的优点。传统阻塞IO为了提高效率，需要创建一定数量的连接形成连接池，而nio仅需要一个连接即可（当然,nio也是可以做池化处理），相对来说减少了线程创建和切换的开销，这一点在高并发下特别明显。因此XMemcached与Spymemcached在性能都非常优秀，在某些方面（存储的数据比较小的情况下）Xmemcached比Spymemcached的表现更为优秀，具体可以看这个 [Java Memcached Clients Benchmark][] 。

## 支持完整的协议 ##

Xmemcached支持所有的memcached协议，包括1.4.0正式开始使用的 [二进制协议][Link 3] 。

## 支持客户端分布 ##

Memcached的分布只能通过客户端来实现，XMemcached实现了此功能，并且提供了一致性哈希(consistent hash)[算法][Link 4]的实现。

## 允许设置节点权重 ##

XMemcached允许通过设置节点的权重来调节memcached的负载，设置的权重越高，该memcached节点存储的数据将越多，所承受的负载越大。

## 动态增删节点 ##

XMemcached允许通过JMX或者代码编程实现节点的动态添加或者移除，方便用户扩展和替换节点等。

## 支持JMX ##

XMemcached通过JMX暴露的一些接口，支持client本身的监控和调整，允许动态设置调优参数、查看统计数据、动态增删节点等。

# xmemcached的分布式 #

由于memcached不支持服务器端分布式，所以m emcached的分布只能通过客户端来实现，xmemcached实现了此功能，并且提供了一致性哈希(consistent hash)算法的实现，关于一致性hashing见http://kb.cnblogs.com/page/42734/

需要说明的是这还只是客户端分布式，不支持主从，各个节点其实还是单独存储，并且未实现存储冗余，节点挂了数据就会相应得丢失

具有如下优势：

## 允许设置节点权重 ##

XMemcached允许通过设置节点的权重来调节memcached的负载，设置的权重越高，该memcached节点存储的数据将越多，所承受的负载越大。

## 动态增删节点 ##

XMemcached允许通过JMX或者代码编程实现节点的动态添加或者移除，方便用户扩展和替换节点等。

## 支持JMX ##

XMemcached通过JMX暴露的一些接口，支持client本身的监控和调整，允许动态设置调优参数、查看统计数据、动态增删节点等

# xmemcached支持的存储对象 #

xmemcached支持的存储比较简单，只要实现了java序列化接口（Serializable接口）的对象就可以存储，当然可以包含Map、Set、List这些复杂对象

# xmemcached的容错性 #

如果当前连接了3个服务器端，其中有一个突然挂掉，那么执行client操作时会抛出异常，但是如果memcached.failureMode=true设置成false那么就不抛出异常，只不过你查询的那个数据显示为null

由于是客户端分布式，所以并未实现存储冗余，如果要冗余需要自己实现代码

# xmemcached的性能测试 #

这里有一个博客介绍了spymemcached和xmemcached的性能对比,http://www.blogjava.net/killme2008/archive/2009/03/04/257852.html

下面我自己来做一个测试

测试环境

memcached版本1.4.22

启动memcached的内存：1G

节点数：3

测试结果单位:tps

先测试简单的String，测试一共开100个线程，每个线程执行10000次操作，结果如下：

再来测试复杂型的Map, 测试一共开50个线程，每个线程执行100次操作，结果如下：

具体代码如下：

**\[java\]**  view plain  copy

print ?

1.  public class PerformanceTest \{  
2.    
3.      static class TestWriteRunnable implements Runnable \{  
4.    
5.          private MemcachedClient mc;  
6.          private CountDownLatch cd;  
7.          int repeat;  
8.          int start;  
9.    
10.         public TestWriteRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) \{  
11.             super();  
12.             this.mc = mc;  
13.             this.start = start;  
14.             this.cd = cdl;  
15.             this.repeat = repeat;  
16.   
17.         \}  
18.   
19.         public void run() \{  
20.             try \{  
21.   
22.                 for (int i = 0; i < repeat; i++) \{  
23.                     String key = String.valueOf(start + i);  
24.                     if (!mc.set(key, 0, key)) \{  
25.                         System.err.println("set error");  
26.                     \}  
27.   
28.                 \}  
29.   
30.             \} catch (Exception e) \{  
31.                 e.printStackTrace();  
32.             \} finally \{  
33.                 cd.countDown();  
34.             \}  
35.         \}  
36.   
37.     \}  
38.   
39.     static class TestReadRunnable implements Runnable \{  
40.   
41.         private MemcachedClient mc;  
42.         private CountDownLatch cd;  
43.         int repeat;  
44.         int start;  
45.   
46.         public TestReadRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) \{  
47.             super();  
48.             this.mc = mc;  
49.             this.start = start;  
50.             this.cd = cdl;  
51.             this.repeat = repeat;  
52.   
53.         \}  
54.   
55.         public void run() \{  
56.             try \{  
57.                 for (int i = 0; i < repeat; i++) \{  
58.   
59.                     String key = String.valueOf(start + i);  
60.                     String result = (String) mc.get(key);  
61.                     if (!key.equals(result)) \{  
62.                         System.out.println(key + " " + result);  
63.                         System.err.println("get error");  
64.                     \}  
65.                 \}  
66.   
67.             \} catch (Exception e) \{  
68.                 e.printStackTrace();  
69.             \} finally \{  
70.                 cd.countDown();  
71.             \}  
72.         \}  
73.   
74.     \}  
75.   
76.     static class TestDeleteRunnable implements Runnable \{  
77.   
78.         private MemcachedClient mc;  
79.         private CountDownLatch cd;  
80.         int repeat;  
81.         int start;  
82.   
83.         public TestDeleteRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) \{  
84.             super();  
85.             this.mc = mc;  
86.             this.start = start;  
87.             this.cd = cdl;  
88.             this.repeat = repeat;  
89.   
90.         \}  
91.   
92.         public void run() \{  
93.             try \{  
94.                 for (int i = 0; i < repeat; i++) \{  
95.                     String key = String.valueOf(start + i);  
96.                     if (!mc.delete(key))  
97.                         System.err.println("delete error");  
98.                 \}  
99.   
100.             \} catch (Exception e) \{  
101.                 e.printStackTrace();  
102.             \} finally \{  
103.                 cd.countDown();  
104.             \}  
105.         \}  
106.   
107.     \}  
108.   
109.     // thread num=10, repeat=10000,size=2, all=200000 ,velocity=1057 , using  
110.     // time:189187  
111.     static public void main(String\[\] args) \{  
112.         try \{  
113.             String address = "192.168.88.140:11211 192.168.88.141:11211 192.168.88.142:11211";  
114.   
115.             int size = Runtime.getRuntime().availableProcessors();  
116.   
117.             int thread = 100;  
118.   
119.             int repeat = 10000;  
120.   
121.             MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(address), new int\[\] \{ 1,  
122.                     1, 1 \});  
123.             MemcachedClient mc = null;  
124.             builder.setConnectionPoolSize(5);  
125.             try \{  
126.                 mc = builder.build();  
127.             \} catch (IOException e) \{  
128.                 e.printStackTrace();  
129.             \}  
130.             CountDownLatch cdl = new CountDownLatch(thread);  
131.             long t = System.currentTimeMillis();  
132.             for (int i = 0; i < thread; i++) \{  
133.                 new Thread(new PerformanceTest.TestWriteRunnable(mc, i \* 10000, cdl, repeat)).start();  
134.             \}  
135.             cdl.await();  
136.             long all = thread \* repeat;  
137.             long usingtime = (System.currentTimeMillis() - t);  
138.   
139.             System.out.println(String.format(  
140.                     "test write,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread, repeat,  
141.                     size, all, 1000 \* all / usingtime, usingtime));  
142.   
143.             cdl = new CountDownLatch(thread);  
144.             t = System.currentTimeMillis();  
145.             for (int i = 0; i < thread; i++) \{  
146.                 new Thread(new PerformanceTest.TestReadRunnable(mc, i \* 10000, cdl, repeat)).start();  
147.             \}  
148.             cdl.await();  
149.             all = thread \* repeat;  
150.             usingtime = (System.currentTimeMillis() - t);  
151.             System.out.println(String.format(  
152.                     "test read,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread, repeat,  
153.                     size, all, 1000 \* all / usingtime, usingtime));  
154.             cdl = new CountDownLatch(thread);  
155.             t = System.currentTimeMillis();  
156.             for (int i = 0; i < thread; i++) \{  
157.                 new Thread(new PerformanceTest.TestDeleteRunnable(mc, i \* 10000, cdl, repeat)).start();  
158.             \}  
159.             cdl.await();  
160.             all = thread \* repeat;  
161.             usingtime = (System.currentTimeMillis() - t);  
162.             System.out.println(String.format(  
163.                     "test delete,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread,  
164.                     repeat, size, all, 1000 \* all / usingtime, usingtime));  
165.   
166.             mc.shutdown();  
167.         \} catch (Exception e) \{  
168.             e.printStackTrace();  
169.         \}  
170.     \}  
171. \}

public class PerformanceTest {
    
    	static class TestWriteRunnable implements Runnable {
    
    		private MemcachedClient mc;
    		private CountDownLatch cd;
    		int repeat;
    		int start;
    
    		public TestWriteRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) {
    			super();
    			this.mc = mc;
    			this.start = start;
    			this.cd = cdl;
    			this.repeat = repeat;
    
    		}
    
    		public void run() {
    			try {
    
    				for (int i = 0; i < repeat; i++) {
    					String key = String.valueOf(start + i);
    					if (!mc.set(key, 0, key)) {
    						System.err.println("set error");
    					}
    
    				}
    
    			} catch (Exception e) {
    				e.printStackTrace();
    			} finally {
    				cd.countDown();
    			}
    		}
    
    	}
    
    	static class TestReadRunnable implements Runnable {
    
    		private MemcachedClient mc;
    		private CountDownLatch cd;
    		int repeat;
    		int start;
    
    		public TestReadRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) {
    			super();
    			this.mc = mc;
    			this.start = start;
    			this.cd = cdl;
    			this.repeat = repeat;
    
    		}
    
    		public void run() {
    			try {
    				for (int i = 0; i < repeat; i++) {
    
    					String key = String.valueOf(start + i);
    					String result = (String) mc.get(key);
    					if (!key.equals(result)) {
    						System.out.println(key + " " + result);
    						System.err.println("get error");
    					}
    				}
    
    			} catch (Exception e) {
    				e.printStackTrace();
    			} finally {
    				cd.countDown();
    			}
    		}
    
    	}
    
    	static class TestDeleteRunnable implements Runnable {
    
    		private MemcachedClient mc;
    		private CountDownLatch cd;
    		int repeat;
    		int start;
    
    		public TestDeleteRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) {
    			super();
    			this.mc = mc;
    			this.start = start;
    			this.cd = cdl;
    			this.repeat = repeat;
    
    		}
    
    		public void run() {
    			try {
    				for (int i = 0; i < repeat; i++) {
    					String key = String.valueOf(start + i);
    					if (!mc.delete(key))
    						System.err.println("delete error");
    				}
    
    			} catch (Exception e) {
    				e.printStackTrace();
    			} finally {
    				cd.countDown();
    			}
    		}
    
    	}
    
    	// thread num=10, repeat=10000,size=2, all=200000 ,velocity=1057 , using
    	// time:189187
    	static public void main(String[] args) {
    		try {
    			String address = "192.168.88.140:11211 192.168.88.141:11211 192.168.88.142:11211";
    
    			int size = Runtime.getRuntime().availableProcessors();
    
    			int thread = 100;
    
    			int repeat = 10000;
    
    			MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(address), new int[] { 1,
    					1, 1 });
    			MemcachedClient mc = null;
    			builder.setConnectionPoolSize(5);
    			try {
    				mc = builder.build();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    			CountDownLatch cdl = new CountDownLatch(thread);
    			long t = System.currentTimeMillis();
    			for (int i = 0; i < thread; i++) {
    				new Thread(new PerformanceTest.TestWriteRunnable(mc, i * 10000, cdl, repeat)).start();
    			}
    			cdl.await();
    			long all = thread * repeat;
    			long usingtime = (System.currentTimeMillis() - t);
    
    			System.out.println(String.format(
    					"test write,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread, repeat,
    					size, all, 1000 * all / usingtime, usingtime));
    
    			cdl = new CountDownLatch(thread);
    			t = System.currentTimeMillis();
    			for (int i = 0; i < thread; i++) {
    				new Thread(new PerformanceTest.TestReadRunnable(mc, i * 10000, cdl, repeat)).start();
    			}
    			cdl.await();
    			all = thread * repeat;
    			usingtime = (System.currentTimeMillis() - t);
    			System.out.println(String.format(
    					"test read,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread, repeat,
    					size, all, 1000 * all / usingtime, usingtime));
    			cdl = new CountDownLatch(thread);
    			t = System.currentTimeMillis();
    			for (int i = 0; i < thread; i++) {
    				new Thread(new PerformanceTest.TestDeleteRunnable(mc, i * 10000, cdl, repeat)).start();
    			}
    			cdl.await();
    			all = thread * repeat;
    			usingtime = (System.currentTimeMillis() - t);
    			System.out.println(String.format(
    					"test delete,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread,
    					repeat, size, all, 1000 * all / usingtime, usingtime));
    
    			mc.shutdown();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }

**\[java\]**  view plain  copy

print ?

1.  public class PerformanceTest2 \{  
2.      static Map<String, Book> map2 = new HashMap<String, Book>();  
3.      static final int ELEMENT\_NUM = 100;  
4.      static \{  
5.          for (int i = 0; i < ELEMENT\_NUM; i++)  
6.              map2.put(String.valueOf(i), new Book(i, String.valueOf(i), String.valueOf(i)));  
7.      \}  
8.    
9.      static class TestWriteRunnable implements Runnable \{  
10.   
11.         private MemcachedClient mc;  
12.         private CountDownLatch cd;  
13.         int repeat;  
14.         int start;  
15.   
16.         public TestWriteRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) \{  
17.             super();  
18.             this.mc = mc;  
19.             this.start = start;  
20.             this.cd = cdl;  
21.             this.repeat = repeat;  
22.   
23.         \}  
24.   
25.         public void run() \{  
26.             try \{  
27.   
28.                 for (int i = 0; i < repeat; i++) \{  
29.                     String key = String.valueOf(start + i);  
30.                     if (!mc.set(key, 0, map2)) \{  
31.                         System.err.println("set error");  
32.                     \}  
33.   
34.                 \}  
35.   
36.             \} catch (Exception e) \{  
37.                 e.printStackTrace();  
38.             \} finally \{  
39.                 cd.countDown();  
40.             \}  
41.         \}  
42.   
43.     \}  
44.   
45.     static class TestReadRunnable implements Runnable \{  
46.   
47.         private MemcachedClient mc;  
48.         private CountDownLatch cd;  
49.         int repeat;  
50.         int start;  
51.   
52.         public TestReadRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) \{  
53.             super();  
54.             this.mc = mc;  
55.             this.start = start;  
56.             this.cd = cdl;  
57.             this.repeat = repeat;  
58.   
59.         \}  
60.   
61.         @SuppressWarnings("unchecked")  
62.         public void run() \{  
63.             try \{  
64.                 for (int i = 0; i < repeat; i++) \{  
65.   
66.                     String key = String.valueOf(start + i);  
67.                     Map<String, Book> result = (Map<String, Book>) mc.get(key);  
68.                     if (result.size() != ELEMENT\_NUM) \{  
69.                         System.err.println("get error");  
70.                     \}  
71.                 \}  
72.   
73.             \} catch (Exception e) \{  
74.                 e.printStackTrace();  
75.             \} finally \{  
76.                 cd.countDown();  
77.             \}  
78.         \}  
79.   
80.     \}  
81.   
82.     static class TestDeleteRunnable implements Runnable \{  
83.   
84.         private MemcachedClient mc;  
85.         private CountDownLatch cd;  
86.         int repeat;  
87.         int start;  
88.   
89.         public TestDeleteRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) \{  
90.             super();  
91.             this.mc = mc;  
92.             this.start = start;  
93.             this.cd = cdl;  
94.             this.repeat = repeat;  
95.   
96.         \}  
97.   
98.         public void run() \{  
99.             try \{  
100.                 for (int i = 0; i < repeat; i++) \{  
101.                     String key = String.valueOf(start + i);  
102.                     if (!mc.delete(key))  
103.                         System.err.println("delete error");  
104.                 \}  
105.   
106.             \} catch (Exception e) \{  
107.                 e.printStackTrace();  
108.             \} finally \{  
109.                 cd.countDown();  
110.             \}  
111.         \}  
112.   
113.     \}  
114.   
115.     // thread num=10, repeat=10000,size=2, all=200000 ,velocity=1057 , using  
116.     // time:189187  
117.     static public void main(String\[\] args) \{  
118.         try \{  
119.             String address = "192.168.88.140:11211 192.168.88.141:11211 192.168.88.142:11211";  
120.   
121.             int size = Runtime.getRuntime().availableProcessors();  
122.   
123.             int thread = 50;  
124.   
125.             int repeat = 100;  
126.   
127.             MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(address), new int\[\] \{ 1,  
128.                     1, 1 \});  
129.             MemcachedClient mc = null;  
130.             builder.setConnectionPoolSize(5);  
131.             try \{  
132.                 mc = builder.build();  
133.             \} catch (IOException e) \{  
134.                 e.printStackTrace();  
135.             \}  
136.   
137.             CountDownLatch cdl = new CountDownLatch(thread);  
138.             long t = System.currentTimeMillis();  
139.             for (int i = 0; i < thread; i++) \{  
140.                 new Thread(new PerformanceTest2.TestWriteRunnable(mc, i \* 10000, cdl, repeat)).start();  
141.             \}  
142.             try \{  
143.                 cdl.await();  
144.             \} catch (InterruptedException e) \{  
145.   
146.             \}  
147.             long all = thread \* repeat;  
148.             long usingtime = (System.currentTimeMillis() - t);  
149.   
150.             System.out.println(String.format(  
151.                     "test write,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread, repeat,  
152.                     size, all, 1000 \* all / usingtime, usingtime));  
153.   
154.             cdl = new CountDownLatch(thread);  
155.             t = System.currentTimeMillis();  
156.             for (int i = 0; i < thread; i++) \{  
157.                 new Thread(new PerformanceTest2.TestReadRunnable(mc, i \* 10000, cdl, repeat)).start();  
158.             \}  
159.             try \{  
160.                 cdl.await();  
161.             \} catch (InterruptedException e) \{  
162.   
163.             \}  
164.             all = thread \* repeat;  
165.             usingtime = (System.currentTimeMillis() - t);  
166.             System.out.println(String.format(  
167.                     "test read,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread, repeat,  
168.                     size, all, 1000 \* all / usingtime, usingtime));  
169.             cdl = new CountDownLatch(thread);  
170.             t = System.currentTimeMillis();  
171.             for (int i = 0; i < thread; i++) \{  
172.                 new Thread(new PerformanceTest2.TestDeleteRunnable(mc, i \* 10000, cdl, repeat)).start();  
173.             \}  
174.             try \{  
175.                 cdl.await();  
176.             \} catch (InterruptedException e) \{  
177.   
178.             \}  
179.             all = thread \* repeat;  
180.             usingtime = (System.currentTimeMillis() - t);  
181.             System.out.println(String.format(  
182.                     "test delete,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread,  
183.                     repeat, size, all, 1000 \* all / usingtime, usingtime));  
184.   
185.             mc.shutdown();  
186.         \} catch (Exception e) \{  
187.             e.printStackTrace();  
188.         \}  
189.     \}  
190. \}

public class PerformanceTest2 {
    	static Map<String, Book> map2 = new HashMap<String, Book>();
    	static final int ELEMENT_NUM = 100;
    	static {
    		for (int i = 0; i < ELEMENT_NUM; i++)
    			map2.put(String.valueOf(i), new Book(i, String.valueOf(i), String.valueOf(i)));
    	}
    
    	static class TestWriteRunnable implements Runnable {
    
    		private MemcachedClient mc;
    		private CountDownLatch cd;
    		int repeat;
    		int start;
    
    		public TestWriteRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) {
    			super();
    			this.mc = mc;
    			this.start = start;
    			this.cd = cdl;
    			this.repeat = repeat;
    
    		}
    
    		public void run() {
    			try {
    
    				for (int i = 0; i < repeat; i++) {
    					String key = String.valueOf(start + i);
    					if (!mc.set(key, 0, map2)) {
    						System.err.println("set error");
    					}
    
    				}
    
    			} catch (Exception e) {
    				e.printStackTrace();
    			} finally {
    				cd.countDown();
    			}
    		}
    
    	}
    
    	static class TestReadRunnable implements Runnable {
    
    		private MemcachedClient mc;
    		private CountDownLatch cd;
    		int repeat;
    		int start;
    
    		public TestReadRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) {
    			super();
    			this.mc = mc;
    			this.start = start;
    			this.cd = cdl;
    			this.repeat = repeat;
    
    		}
    
    		@SuppressWarnings("unchecked")
    		public void run() {
    			try {
    				for (int i = 0; i < repeat; i++) {
    
    					String key = String.valueOf(start + i);
    					Map<String, Book> result = (Map<String, Book>) mc.get(key);
    					if (result.size() != ELEMENT_NUM) {
    						System.err.println("get error");
    					}
    				}
    
    			} catch (Exception e) {
    				e.printStackTrace();
    			} finally {
    				cd.countDown();
    			}
    		}
    
    	}
    
    	static class TestDeleteRunnable implements Runnable {
    
    		private MemcachedClient mc;
    		private CountDownLatch cd;
    		int repeat;
    		int start;
    
    		public TestDeleteRunnable(MemcachedClient mc, int start, CountDownLatch cdl, int repeat) {
    			super();
    			this.mc = mc;
    			this.start = start;
    			this.cd = cdl;
    			this.repeat = repeat;
    
    		}
    
    		public void run() {
    			try {
    				for (int i = 0; i < repeat; i++) {
    					String key = String.valueOf(start + i);
    					if (!mc.delete(key))
    						System.err.println("delete error");
    				}
    
    			} catch (Exception e) {
    				e.printStackTrace();
    			} finally {
    				cd.countDown();
    			}
    		}
    
    	}
    
    	// thread num=10, repeat=10000,size=2, all=200000 ,velocity=1057 , using
    	// time:189187
    	static public void main(String[] args) {
    		try {
    			String address = "192.168.88.140:11211 192.168.88.141:11211 192.168.88.142:11211";
    
    			int size = Runtime.getRuntime().availableProcessors();
    
    			int thread = 50;
    
    			int repeat = 100;
    
    			MemcachedClientBuilder builder = new XMemcachedClientBuilder(AddrUtil.getAddresses(address), new int[] { 1,
    					1, 1 });
    			MemcachedClient mc = null;
    			builder.setConnectionPoolSize(5);
    			try {
    				mc = builder.build();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    
    			CountDownLatch cdl = new CountDownLatch(thread);
    			long t = System.currentTimeMillis();
    			for (int i = 0; i < thread; i++) {
    				new Thread(new PerformanceTest2.TestWriteRunnable(mc, i * 10000, cdl, repeat)).start();
    			}
    			try {
    				cdl.await();
    			} catch (InterruptedException e) {
    
    			}
    			long all = thread * repeat;
    			long usingtime = (System.currentTimeMillis() - t);
    
    			System.out.println(String.format(
    					"test write,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread, repeat,
    					size, all, 1000 * all / usingtime, usingtime));
    
    			cdl = new CountDownLatch(thread);
    			t = System.currentTimeMillis();
    			for (int i = 0; i < thread; i++) {
    				new Thread(new PerformanceTest2.TestReadRunnable(mc, i * 10000, cdl, repeat)).start();
    			}
    			try {
    				cdl.await();
    			} catch (InterruptedException e) {
    
    			}
    			all = thread * repeat;
    			usingtime = (System.currentTimeMillis() - t);
    			System.out.println(String.format(
    					"test read,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread, repeat,
    					size, all, 1000 * all / usingtime, usingtime));
    			cdl = new CountDownLatch(thread);
    			t = System.currentTimeMillis();
    			for (int i = 0; i < thread; i++) {
    				new Thread(new PerformanceTest2.TestDeleteRunnable(mc, i * 10000, cdl, repeat)).start();
    			}
    			try {
    				cdl.await();
    			} catch (InterruptedException e) {
    
    			}
    			all = thread * repeat;
    			usingtime = (System.currentTimeMillis() - t);
    			System.out.println(String.format(
    					"test delete,thread num=%d, repeat=%d,size=%d, all=%d ,velocity=%d , using time:%d", thread,
    					repeat, size, all, 1000 * all / usingtime, usingtime));
    
    			mc.shutdown();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }

[Link 1]: http://lib.csdn.net/base/softwaretest
[spring]: http://lib.csdn.net/base/javaee
[Java]: http://lib.csdn.net/base/java
[Link 2]: http://lib.csdn.net/base/mysql
[Java Memcached Clients Benchmark]: http://xmemcached.googlecode.com/svn/trunk/benchmark/benchmark.html
[Link 3]: http://code.google.com/p/memcached/wiki/MemcacheBinaryProtocol
[Link 4]: http://lib.csdn.net/base/datastructure