memcached-java客户端xmemcached使用总结

memcached-java客户端xmemcached使用总结

标签： memcachedxmemcached分布式缓存spring

2015-01-30 09:42  3609人阅读  评论(0)  收藏  举报

  分类：

memcached（2） 

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

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

a. xmemcached简介

b. xmemcached的分布式

c. xmemcached支持的存储对象

d. xmemcached的容错性

e. xmemcached的性能测试

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

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

[plain]  view plain  copy

 

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

以下是properties文件：

[plain]  view plain  copy

 

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  

spring bean配置：

[plain]  view plain  copy

 

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.         <!-- XMemcachedClientBuilder have two arguments.First is server list,and   
18.             second is weights array. -->  
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.         <!-- BinaryCommandFactory -->  
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.     <!-- Use factory bean to build memcached client -->  
66.     <bean id="memcachedClient" factory-bean="memcachedClientBuilder"  
67.         factory-method="build" destroy-method="shutdown" />  
68.   
69. </beans>  

这样就可以用memcachedClient了

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

[java]  view plain  copy

 

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.     }  

xmemcached简介

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

Memcached的java客户端已经存在两个了：官方提供的基于传统阻塞io的客户端 、Dustin Sallings实现的基于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正式开始使用的 二进制协议 。

支持客户端分布

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

允许设置节点权重

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次操作，结果如下：

写	76062
读	91116
删	89863

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

写	2399
读	1901
删	13227

具体代码如下：

[java]  view plain  copy

 

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. }  

[java]  view plain  copy

 

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. }  

顶

0

踩

0

 

 

• 上一篇memcached-java客户端xmemcached简单使用
• 下一篇Spring Web Flow 2.0 入门