首页    技术博客    PHP教程    数据库技术    前端开发   HTML5    Nginx    php论坛
新用户注册 | 会员登录
加入会员，解锁专属内容
取消
热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

memcachedjava客户端xmemcached使用总结与Spring集成

作者：沫小兮 | 来源：互联网 | 2023-08-06 10:20
1.最近调研了下memcached，之前2篇博客简单得介绍了用法，现在做个总结就当调研结束，本博客将从以下几个方面进行总结，

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

a. xmemcached简介

b. xmemcached的分布式

c. xmemcached支持的存储对象

d. xmemcached的容错性

e. xmemcached的性能测试

    由于memcached可以与spring集成&＃xff0c;所以本博客以和spring集成来讲以上几点


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

[plain] view plaincopy
print?
  1.   
  2.             com.googlecode.xmemcached  
  3.             xmemcached  
  4.             2.0.0  
  5.           

com.googlecode.xmemcachedxmemcached2.0.0
以下是properties文件&＃xff1a;

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

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


spring bean配置&＃xff1a;
[plain] view plaincopy
print?
  1.   
  3.     xmlns:xsi&＃61;"http://www.w3.org/2001/XMLSchema-instance" xmlns:context&＃61;"http://www.springframework.org/schema/context"  
  4.     xmlns:p&＃61;"http://www.springframework.org/schema/p" xmlns:c&＃61;"http://www.springframework.org/schema/c"  
  5.     xmlns:rabbit&＃61;"http://www.springframework.org/schema/rabbit" xmlns:task&＃61;"http://www.springframework.org/schema/task"  
  6.     xsi:schemaLocation&＃61;"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.     
  16.         p:connectionPoolSize&＃61;"${memcached.connectionPoolSize}" p:failureMode&＃61;"${memcached.failureMode}">  
  17.           
  18.           
  19.               
  20.                   
  21.                       
  22.                         ${memcached.server1.host}  
  23.                       
  24.                       
  25.                         ${memcached.server1.port}  
  26.                       
  27.                   
  28.                   
  29.                       
  30.                         ${memcached.server2.host}  
  31.                       
  32.                       
  33.                         ${memcached.server2.port}  
  34.                       
  35.                   
  36.                   
  37.                       
  38.                         ${memcached.server3.host}  
  39.                       
  40.                       
  41.                         ${memcached.server3.port}  
  42.                       
  43.                   
  44.               
  45.           
  46.           
  47.               
  48.                 ${memcached.server1.weight}  
  49.                 ${memcached.server2.weight}  
  50.                 ${memcached.server3.weight}  
  51.               
  52.           
  53.           
  54.           
  55.               
  56.           
  57.           
  58.               
  59.           
  60.           
  61.               
  62.           
  63.       
  64.       
  65.     
  66.         factory-method&＃61;"build" destroy-method&＃61;"shutdown" />  
  67.   
  68.   


${memcached.server1.host}${memcached.server1.port}${memcached.server2.host}${memcached.server2.port}${memcached.server3.host}${memcached.server3.port}${memcached.server1.weight}${memcached.server2.weight}${memcached.server3.weight}

这样就可以用memcachedClient了

举个简单的例子说明如何使用&＃xff1a;

[java] view plaincopy
print?
  1. &＃64;Autowired  
  2.     private MemcachedClient memcachedClient;  
  3.   
  4.     public Map queryFromCache(List keys) {  
  5.         Map users &＃61; new HashMap();  
  6.         for (String key : keys) {  
  7.             try {  
  8.                 User user &＃61; 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.     }  

&＃64;Autowiredprivate MemcachedClient memcachedClient;public Map queryFromCache(List keys) {Map users &＃61; new HashMap();for (String key : keys) {try {User user &＃61; 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 memcached client。简单来说&＃xff0c;Memcached 是一个高性能的分布式内存对象的key-value缓存系统&＃xff0c;用于动态Web应用以减轻数据库负载&＃xff0c;现在也有很多人将它作为内存式数据库在使用&＃xff0c;memcached通过它的自定义协议与客户端交互&＃xff0c;而XMemcached就是它的一个Java客户端实现。

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

XMemcached的主要特性

高性能

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

支持完整的协议

Xmemcached支持所有的memcached协议&＃xff0c;包括1.4.0正式开始使用的 二进制协议 。

支持客户端分布

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

允许设置节点权重

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

动态增删节点

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

支持JMX

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

xmemcached的分布式
由于memcached不支持服务器端分布式&＃xff0c;所以memcached的分布只能通过客户端来实现&＃xff0c;xmemcached实现了此功能&＃xff0c;并且提供了一致性哈希(consistent hash)算法的实现&＃xff0c;关于一致性hashing见http://kb.cnblogs.com/page/42734/
需要说明的是这还只是客户端分布式&＃xff0c;不支持主从&＃xff0c;各个节点其实还是单独存储&＃xff0c;并且未实现存储冗余&＃xff0c;节点挂了数据就会相应得丢失
具有如下优势&＃xff1a;

允许设置节点权重

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

动态增删节点

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

支持JMX

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


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

xmemcached的容错性
如果当前连接了3个服务器端&＃xff0c;其中有一个突然挂掉&＃xff0c;那么执行client操作时会抛出异常&＃xff0c;但是如果memcached.failureMode&＃61;true设置成false那么就不抛出异常&＃xff0c;只不过你查询的那个数据显示为null
由于是客户端分布式&＃xff0c;所以并未实现存储冗余&＃xff0c;如果要冗余需要自己实现代码

xmemcached的性能测试
这里有一个博客介绍了spymemcached和xmemcached的性能对比,http://www.blogjava.net/killme2008/archive/2009/03/04/257852.html
下面我自己来做一个测试
测试环境
memcached版本1.4.22
启动memcached的内存&＃xff1a;1G
节点数&＃xff1a;3

测试结果单位:tps

先测试简单的String&＃xff0c;测试一共开100个线程&＃xff0c;每个线程执行10000次操作&＃xff0c;结果如下&＃xff1a;
写76062
读91116
删89863

再来测试复杂型的Map, 测试一共开50个线程&＃xff0c;每个线程执行100次操作&＃xff0c;结果如下&＃xff1a;
写2399
读1901
删13227

具体代码如下&＃xff1a;
[java] view plaincopy
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 &＃61; mc;  
  13.             this.start &＃61; start;  
  14.             this.cd &＃61; cdl;  
  15.             this.repeat &＃61; repeat;  
  16.   
  17.         }  
  18.   
  19.         public void run() {  
  20.             try {  
  21.   
  22.                 for (int i &＃61; 0; i < repeat; i&＃43;&＃43;) {  
  23.                     String key &＃61; String.valueOf(start &＃43; 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 &＃61; mc;  
  49.             this.start &＃61; start;  
  50.             this.cd &＃61; cdl;  
  51.             this.repeat &＃61; repeat;  
  52.   
  53.         }  
  54.   
  55.         public void run() {  
  56.             try {  
  57.                 for (int i &＃61; 0; i < repeat; i&＃43;&＃43;) {  
  58.   
  59.                     String key &＃61; String.valueOf(start &＃43; i);  
  60.                     String result &＃61; (String) mc.get(key);  
  61.                     if (!key.equals(result)) {  
  62.                         System.out.println(key &＃43; " " &＃43; 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 &＃61; mc;  
  86.             this.start &＃61; start;  
  87.             this.cd &＃61; cdl;  
  88.             this.repeat &＃61; repeat;  
  89.   
  90.         }  
  91.   
  92.         public void run() {  
  93.             try {  
  94.                 for (int i &＃61; 0; i < repeat; i&＃43;&＃43;) {  
  95.                     String key &＃61; String.valueOf(start &＃43; 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&＃61;10, repeat&＃61;10000,size&＃61;2, all&＃61;200000 ,velocity&＃61;1057 , using  
  110.     // time:189187  
  111.     static public void main(String[] args) {  
  112.         try {  
  113.             String address &＃61; "192.168.88.140:11211 192.168.88.141:11211 192.168.88.142:11211";  
  114.   
  115.             int size &＃61; Runtime.getRuntime().availableProcessors();  
  116.   
  117.             int thread &＃61; 100;  
  118.   
  119.             int repeat &＃61; 10000;  
  120.   
  121.             MemcachedClientBuilder builder &＃61; new XMemcachedClientBuilder(AddrUtil.getAddresses(address), new int[] { 1,  
  122.                     1, 1 });  
  123.             MemcachedClient mc &＃61; null;  
  124.             builder.setConnectionPoolSize(5);  
  125.             try {  
  126.                 mc &＃61; builder.build();  
  127.             } catch (IOException e) {  
  128.                 e.printStackTrace();  
  129.             }  
  130.             CountDownLatch cdl &＃61; new CountDownLatch(thread);  
  131.             long t &＃61; System.currentTimeMillis();  
  132.             for (int i &＃61; 0; i < thread; i&＃43;&＃43;) {  
  133.                 new Thread(new PerformanceTest.TestWriteRunnable(mc, i * 10000, cdl, repeat)).start();  
  134.             }  
  135.             cdl.await();  
  136.             long all &＃61; thread * repeat;  
  137.             long usingtime &＃61; (System.currentTimeMillis() - t);  
  138.   
  139.             System.out.println(String.format(  
  140.                     "test write,thread num&＃61;%d, repeat&＃61;%d,size&＃61;%d, all&＃61;%d ,velocity&＃61;%d , using time:%d", thread, repeat,  
  141.                     size, all, 1000 * all / usingtime, usingtime));  
  142.   
  143.             cdl &＃61; new CountDownLatch(thread);  
  144.             t &＃61; System.currentTimeMillis();  
  145.             for (int i &＃61; 0; i < thread; i&＃43;&＃43;) {  
  146.                 new Thread(new PerformanceTest.TestReadRunnable(mc, i * 10000, cdl, repeat)).start();  
  147.             }  
  148.             cdl.await();  
  149.             all &＃61; thread * repeat;  
  150.             usingtime &＃61; (System.currentTimeMillis() - t);  
  151.             System.out.println(String.format(  
  152.                     "test read,thread num&＃61;%d, repeat&＃61;%d,size&＃61;%d, all&＃61;%d ,velocity&＃61;%d , using time:%d", thread, repeat,  
  153.                     size, all, 1000 * all / usingtime, usingtime));  
  154.             cdl &＃61; new CountDownLatch(thread);  
  155.             t &＃61; System.currentTimeMillis();  
  156.             for (int i &＃61; 0; i < thread; i&＃43;&＃43;) {  
  157.                 new Thread(new PerformanceTest.TestDeleteRunnable(mc, i * 10000, cdl, repeat)).start();  
  158.             }  
  159.             cdl.await();  
  160.             all &＃61; thread * repeat;  
  161.             usingtime &＃61; (System.currentTimeMillis() - t);  
  162.             System.out.println(String.format(  
  163.                     "test delete,thread num&＃61;%d, repeat&＃61;%d,size&＃61;%d, all&＃61;%d ,velocity&＃61;%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 &＃61; mc;this.start &＃61; start;this.cd &＃61; cdl;this.repeat &＃61; repeat;}public void run() {try {for (int i &＃61; 0; i }


[java] view plaincopy
print?
  1. public class PerformanceTest2 {  
  2.     static Map map2 &＃61; new HashMap();  
  3.     static final int ELEMENT_NUM &＃61; 100;  
  4.     static {  
  5.         for (int i &＃61; 0; i < ELEMENT_NUM; i&＃43;&＃43;)  
  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 &＃61; mc;  
  19.             this.start &＃61; start;  
  20.             this.cd &＃61; cdl;  
  21.             this.repeat &＃61; repeat;  
  22.   
  23.         }  
  24.   
  25.         public void run() {  
  26.             try {  
  27.   
  28.                 for (int i &＃61; 0; i < repeat; i&＃43;&＃43;) {  
  29.                     String key &＃61; String.valueOf(start &＃43; 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 &＃61; mc;  
  55.             this.start &＃61; start;  
  56.             this.cd &＃61; cdl;  
  57.             this.repeat &＃61; repeat;  
  58.   
  59.         }  
  60.   
  61.         &＃64;SuppressWarnings("unchecked")  
  62.         public void run() {  
  63.             try {  
  64.                 for (int i &＃61; 0; i < repeat; i&＃43;&＃43;) {  
  65.   
  66.                     String key &＃61; String.valueOf(start &＃43; i);  
  67.                     Map result &＃61; (Map) mc.get(key);  
  68.                     if (result.size() !&＃61; 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 &＃61; mc;  
  92.             this.start &＃61; start;  
  93.             this.cd &＃61; cdl;  
  94.             this.repeat &＃61; repeat;  
  95.   
  96.         }  
  97.   
  98.         public void run() {  
  99.             try {  
  100.                 for (int i &＃61; 0; i < repeat; i&＃43;&＃43;) {  
  101.                     String key &＃61; String.valueOf(start &＃43; 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&＃61;10, repeat&＃61;10000,size&＃61;2, all&＃61;200000 ,velocity&＃61;1057 , using  
  116.     // time:189187  
  117.     static public void main(String[] args) {  
  118.         try {  
  119.             String address &＃61; "192.168.88.140:11211 192.168.88.141:11211 192.168.88.142:11211";  
  120.   
  121.             int size &＃61; Runtime.getRuntime().availableProcessors();  
  122.   
  123.             int thread &＃61; 50;  
  124.   
  125.             int repeat &＃61; 100;  
  126.   
  127.             MemcachedClientBuilder builder &＃61; new XMemcachedClientBuilder(AddrUtil.getAddresses(address), new int[] { 1,  
  128.                     1, 1 });  
  129.             MemcachedClient mc &＃61; null;  
  130.             builder.setConnectionPoolSize(5);  
  131.             try {  
  132.                 mc &＃61; builder.build();  
  133.             } catch (IOException e) {  
  134.                 e.printStackTrace();  
  135.             }  
  136.   
  137.             CountDownLatch cdl &＃61; new CountDownLatch(thread);  
  138.             long t &＃61; System.currentTimeMillis();  
  139.             for (int i &＃61; 0; i < thread; i&＃43;&＃43;) {  
  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 &＃61; thread * repeat;  
  148.             long usingtime &＃61; (System.currentTimeMillis() - t);  
  149.   
  150.             System.out.println(String.format(  
  151.                     "test write,thread num&＃61;%d, repeat&＃61;%d,size&＃61;%d, all&＃61;%d ,velocity&＃61;%d , using time:%d", thread, repeat,  
  152.                     size, all, 1000 * all / usingtime, usingtime));  
  153.   
  154.             cdl &＃61; new CountDownLatch(thread);  
  155.             t &＃61; System.currentTimeMillis();  
  156.             for (int i &＃61; 0; i < thread; i&＃43;&＃43;) {  
  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 &＃61; thread * repeat;  
  165.             usingtime &＃61; (System.currentTimeMillis() - t);  
  166.             System.out.println(String.format(  
  167.                     "test read,thread num&＃61;%d, repeat&＃61;%d,size&＃61;%d, all&＃61;%d ,velocity&＃61;%d , using time:%d", thread, repeat,  
  168.                     size, all, 1000 * all / usingtime, usingtime));  
  169.             cdl &＃61; new CountDownLatch(thread);  
  170.             t &＃61; System.currentTimeMillis();  
  171.             for (int i &＃61; 0; i < thread; i&＃43;&＃43;) {  
  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 &＃61; thread * repeat;  
  180.             usingtime &＃61; (System.currentTimeMillis() - t);  
  181.             System.out.println(String.format(  
  182.                     "test delete,thread num&＃61;%d, repeat&＃61;%d,size&＃61;%d, all&＃61;%d ,velocity&＃61;%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 map2 &＃61; new HashMap();static final int ELEMENT_NUM &＃61; 100;static {for (int i &＃61; 0; i result &＃61; (Map) mc.get(key);if (result.size() !&＃61; 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 &＃61; mc;this.start &＃61; start;this.cd &＃61; cdl;this.repeat &＃61; repeat;}public void run() {try {for (int i &＃61; 0; i }




推荐阅读
  • include

    vue使用

    vue使用
    关键词： ... [详细]
  • java

    在类中定义数组时出错 - Error on defining arrays in class

    Iamtryingtomakeaclassthatwillreadatextfileofnamesintoanarray,thenreturnthatarra ... [详细]
  • ip

    Nginx使用（server参数配置）

    Nginx使用（server参数配置）
    本文介绍了Nginx的使用，重点讲解了server参数配置，包括端口号、主机名、根目录等内容。同时，还介绍了Nginx的反向代理功能。 ... [详细]
  • ip

    SpringBoot yml 配置 多配置文件,开发环境,生产环境配置文件分开

    原文地址:https:www.cnblogs.combaoyipSpringBoot_YML.html1.在springboot中，有两种配置文件，一种 ... [详细]
  • text

    Go GUIlxn/walk 学习3.菜单栏和工具栏的具体实现

    Go GUIlxn/walk 学习3.菜单栏和工具栏的具体实现
    本文介绍了使用Go语言的GUI库lxn/walk实现菜单栏和工具栏的具体方法，包括消息窗口的产生、文件放置动作响应和提示框的应用。部分代码来自上一篇博客和lxn/walk官方示例。文章提供了学习GUI开发的实际案例和代码示例。 ... [详细]
  • java

    javaweb多图片打包下载，弹出提示框问题_html/css_WEBITnose

    在springmvc框架中，前台ajax调用方法，对图片批量下载，如何弹出提示保存位置选框？Controller方法 ... [详细]
  • ip

    SpringMVC接收请求参数的方式总结

    SpringMVC接收请求参数的方式总结
    本文总结了在SpringMVC开发中处理控制器参数的各种方式，包括处理使用@RequestParam注解的参数、MultipartFile类型参数和Simple类型参数的RequestParamMethodArgumentResolver，处理@RequestBody注解的参数的RequestResponseBodyMethodProcessor，以及PathVariableMapMethodArgumentResol等子类。 ... [详细]
  • ip

    SpringBoot整合SpringSecurity+JWT实现单点登录

    SpringBoot整合SpringSecurity+JWT实现单点登录
    SpringBoot整合SpringSecurity+JWT实现单点登录,Go语言社区,Golang程序员人脉社 ... [详细]
  • java

    一次上线事故，30岁+的程序员踩坑经验之谈

    一次上线事故，30岁+的程序员踩坑经验之谈
    本文主要介绍了一位30岁+的程序员在一次上线事故中踩坑的经验之谈。文章提到了在双十一活动期间，作为一个在线医疗项目，他们进行了优惠折扣活动的升级改造。然而，在上线前的最后一天，由于大量数据请求，导致部分接口出现问题。作者通过部署两台opentsdb来解决问题，但读数据的opentsdb仍然经常假死。作者只能查询最近24小时的数据。这次事故给他带来了很多教训和经验。 ... [详细]
  • java

    开发笔记：spring boot项目打成war包部署到服务器的步骤与注意事项

    开发笔记：spring boot项目打成war包部署到服务器的步骤与注意事项
    本文介绍了将spring boot项目打成war包并部署到服务器的步骤与注意事项。通过本文的学习，读者可以了解到如何将spring boot项目打包成war包，并成功地部署到服务器上。 ... [详细]
  • ip

    Java如何导入和导出Excel文件的方法和步骤详解

    Java如何导入和导出Excel文件的方法和步骤详解
    本文详细介绍了在SpringBoot中使用Java导入和导出Excel文件的方法和步骤，包括添加操作Excel的依赖、自定义注解等。文章还提供了示例代码，并将代码上传至GitHub供访问。 ... [详细]
  • java

    Spring框架《一》简介

    Spring框架《一》简介
    Spring框架《一》1.Spring概述1.1简介1.2Spring模板二、IOC容器和Bean1.IOC和DI简介2.三种通过类型获取bean3.给bean的属性赋值3.1依赖 ... [详细]
  • client

    Sleuth+zipkin链路追踪SpringCloud微服务的解决方案

    Sleuth+zipkin链路追踪SpringCloud微服务的解决方案
    在庞大的微服务群中，随着业务扩展，微服务个数增多，系统调用链路复杂化。Sleuth+zipkin是解决SpringCloud微服务定位和追踪的方案。通过TraceId将不同服务调用的日志串联起来，实现请求链路跟踪。通过Feign调用和Request传递TraceId，将整个调用链路的服务日志归组合并，提供定位和追踪的功能。 ... [详细]
  • client

    初学者遇到的dubbo设计架构问题及解决方法总结

    本文总结了初学者在使用dubbo设计架构过程中遇到的问题，并提供了相应的解决方法。问题包括传输字节流限制、分布式事务、序列化、多点部署、zk端口冲突、服务失败请求3次机制以及启动时检查。通过解决这些问题，初学者能够更好地理解和应用dubbo设计架构。 ... [详细]
  • less

    Git版本控制工具中自动增加版本号的替代方案

    本文讨论了在使用Git进行版本控制时，如何提供类似CVS中自动增加版本号的功能。作者介绍了Git中的其他版本表示方式，如git describe命令，并提供了使用这些表示方式来确定文件更新情况的示例。此外，文章还介绍了启用$Id:$功能的方法，并讨论了一些开发者在使用Git时的需求和使用场景。 ... [详细]
author-avatar
沫小兮
这个家伙很懒，什么也没留下！
Tags | 热门标签
RankList | 热门文章
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有