ehcache集群测试报告

已于 2023-05-04 17:53:00 修改
阅读量142 收藏 1
点赞数
分类专栏： Ehcache和Redis的缓存兼容开放组件设计方案 文章标签： java 缓存 spring
于 2023-03-21 09:13:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/donkeyboy001/article/details/129680943
版权
这篇测试报告详细描述了在Java环境下使用Ehcache进行集群配置的测试过程。测试涉及缓存的添加和获取操作，通过在两台服务器上进行并发线程测试，观察缓存同步效率。测试结果显示，40000个元素从一台服务器添加到缓存后，另一台服务器在首次同步时耗时0.708秒。测试提供了缓存配置信息、代码解析和测试日志，为理解和优化Ehcache集群性能提供了参考。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.测试环境

CPU核心数内存主机地址
Server1816G10.2.6.77
Server2816G10.2.6.78

2.测试代码

TestController 

/**
 * @Description:测试
 * @Author: gezongyang
 **/
@Api(tags="test")
@RestController
@RequestMapping("/test")
@Slf4j
public class TestController {

    @AutoLog(value = "缓存添加测试")
    @ApiOperation(value="缓存添加测试")
    @GetMapping(value = "/testPutCache")
    public Result testPutCache() throws InterruptedException {

        ShareData shareData = new ShareData();
        CountDownLatch countDownLatch = new CountDownLatch(4);
        CachePutThread cachePutThread = new CachePutThread(shareData, countDownLatch);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(4, 1000, 5, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
        LocalDateTime start = LocalDateTime.now();
        for (int i = 0; i < 4; i++) {
            executor.execute(cachePutThread);
        }
        countDownLatch.await();
        LocalDateTime end = LocalDateTime.now();
        int i = end.getSecond() - start.getSecond();
        log.info("缓存添加开始时间:{}-缓存添加结束时间:{} 用时:{} 秒",start.toString(),end.toString(),String.valueOf(i));
        executor.shutdown();
        return Result.OK("success");
    }

    @AutoLog(value = "缓存获取测试")
    @ApiOperation(value="缓存获取测试")
    @GetMapping(value = "/testGetCache")
    public Result testGetCache() throws InterruptedException {

        ShareData shareData = new ShareData();

        CountDownLatch countDownLatch = new CountDownLatch(4);
        CacheGetThread cacheGetThread = new CacheGetThread(shareData, countDownLatch);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(4, 1000, 5, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());

        for (int i = 0; i < 4; i++) {
            executor.execute(cacheGetThread);
        }
        countDownLatch.await();
        LocalDateTime start = shareData.getStartTime();
        LocalDateTime end = LocalDateTime.now();
        int i = end.getSecond() - start.getSecond();
        log.info("缓存获取开始时间:{}-缓存获取结束时间:{} 用时:{} 秒", start.toString(), end.toString(), String.valueOf(i));
        executor.shutdown();
        return Result.OK("success");
    }

    @AutoLog(value = "缓存清除")
    @ApiOperation(value="缓存清除")
    @GetMapping(value = "/testFlush")
    public Result flushCache() throws InterruptedException {


        CacheUtil.clear();
        System.out.println("----------缓存获取完成-----------");

        return Result.OK("success");
    }
}

ShareData

/**
 * @Description TODO
 * @Version 1.0
 * @Author gezongyang
 */
@Slf4j
@Data
public class ShareData {

    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condtion = lock.newCondition();
    LocalDateTime startTime;

    public void put() throws InterruptedException {
        lock.lock();
        try {
            ++number;
            CacheUtil.set(String.valueOf(number), String.valueOf(number));
            LocalDateTime now = LocalDateTime.now();
            log.info("放入缓存时间:{} - key:{} -> value: {}", now.toString(), String.valueOf(number), String.valueOf(number));
            condtion.signalAll(); //this.notify()
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void get() throws InterruptedException {
        lock.lock();
        try {
            ++number;
            Object value = CacheUtil.get(String.valueOf(number));
            while (value == null) {
                value = CacheUtil.get(String.valueOf(number));
                if (value != null) {
                    LocalDateTime now = LocalDateTime.now();
                    if (number == 1) {
                        log.info("获取缓存开始时间:{} - key:{} -> value: {}", now.toString(), String.valueOf(number), value);
                        startTime = now;
                    } else {
                        log.info("获取缓存时间:{} - key:{} -> value: {}", now.toString(), String.valueOf(number), value);
                        break;
                    }
                }
            }

            condtion.signalAll(); //this.notify()
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        System.out.println(LocalDateTime.now());
    }

}

CacheGetThread

/**
 * @Description TODO
 * @Version 1.0
 * @Author gezongyang
 */
public class CacheGetThread implements Runnable {

    ShareData shareData;
    CountDownLatch countDownLatch;

    public CacheGetThread(ShareData shareData, CountDownLatch countDownLatch) {
        this.shareData = shareData;
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
            try {
                for (int i = 0; i < 10000; i++) {
                    shareData.get();
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                countDownLatch.countDown();
            }
    }
}

CachePutThread

/**
 * @Description TODO
 * @Version 1.0
 * @Author gezongyang
 */
public class CachePutThread implements Runnable {

    private final Logger logger = LoggerFactory.getLogger(CachePutThread.class);
    ShareData shareData;
    CountDownLatch countDownLatch;

    public CachePutThread(ShareData shareData, CountDownLatch countDownLatch) {
        this.shareData = shareData;
        this.countDownLatch = countDownLatch;
    }
    
    @Override
    public void run() {
        try {
            for (int i = 0; i < 10000; i++) {
                shareData.put();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            countDownLatch.countDown();
        }

    }
}

测试代码解析：

类名类说明
TestController测试类，提供缓存添加、获取、删除的请求接口
ShareData共享数据，里面封装缓存的获取和添加方法
CacheGetThread缓存获取线程
CachePutThread缓存放入线程

/testPutCache： 调用4个线程向缓存中添加数据，每个线程添加10000条

/testGetCache： 调用4个线程从缓存中取数据，每个线程取10000条

3.缓存配置信息

 10.2.6.77

 cluster:
   provider:
     peer-discovery: manual
     manual:
       rmi-urls: 10.2.6.78:40002  #缓存提供者需要通知的rmi地址 多个 | 分隔
   listener:
     host-name: 10.2.6.77  #缓存监听者端口地址 默认:127.0.0.1
     port: 40002
     socket-timeout-millis: 2000 #监听socket连接超时时间 默认2000毫秒

10.2.6.78

 cluster:
   provider:
     peer-discovery: manual
       manual:
         rmi-urls: 10.2.6.77:40002  #缓存提供者需要通知的rmi地址 多个 | 分隔
   listener:
     host-name: 10.2.6.78  #缓存监听者端口地址 默认:127.0.0.1
     port: 40002
     socket-timeout-millis: 2000 #监听socket连接超时时间 默认2000毫秒

4.缓存测试

（1）在 服务器10.2.6.78 上调用缓存的获取方法，这个时候因为缓存中还没有数据，四个线程会先等待

/test/testGetCache

（2）在 服务器10.2.6.77 上调用缓存的添加方法

/test/testPutCache

5.缓存测试日志

10.2.6.77

2022-11-15 17:00:01.361 [pool-1-thread-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:35[0;39m - 放入缓存时间:2022-11-15T17:00:01.360 - key:1 -> value: 1
2022-11-15 17:00:01.361 [pool-1-thread-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:35[0;39m - 放入缓存时间:2022-11-15T17:00:01.361 - key:2 -> value: 2
2022-11-15 17:00:01.361 [pool-1-thread-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:35[0;39m - 放入缓存时间:2022-11-15T17:00:01.361 - key:3 -> value: 3
2022-11-15 17:00:01.361 [pool-1-thread-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:35[0;39m - 放入缓存时间:2022-11-15T17:00:01.361 - key:4 -> value: 4
2022-11-15 17:00:01.362 [pool-1-thread-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:35[0;39m - 放入缓存时间:2022-11-15T17:00:01.362 - key:5 -> value: 5
2022-11-15 17:00:01.362 [pool-1-thread-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:35[0;39m - 放入缓存时间:2022-11-15T17:00:01.362 - key:6 -> value: 6
2022-11-15 17:00:01.362 [pool-1-thread-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:35[0;39m - 放入缓存时间:2022-11-15T17:00:01.362 - key:7 -> value: 7
2022-11-15 17:00:01.362 [pool-1-thread-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:35[0;39m - 放入缓存时间:2022-11-15T17:00:01.362 - key:8 -> value: 8
2022-11-15 17:00:01.362 [pool-1-thread-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:35[0;39m - 放入缓存时间:2022-11-15T17:00:01.362 - key:9 -> value: 9
2022-11-15 17:00:01.362 [pool-1-thread-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:35[0;39m - 放入缓存时间:2022-11-15T17:00:01.362 - key:10 -> value: 10
...
2022-11-15 17:00:03.503 [http-nio-9000-exec-2] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.controller.TestController1:190[0;39m - 缓存添加开始时间:2022-11-15T17:00:01.349-缓存添加结束时间:2022-11-15T17:00:03.503 用时:2 秒

10.2.6.78

2022-11-15 17:00:02.068 [pool-1-thread-1] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:54[0;39m - 获取缓存开始时间:2022-11-15T17:00:02.068 - key:1 -> value: 1
2022-11-15 17:00:02.068 [RMI TCP Connection(4)-10.2.6.77] [39mDEBUG[0;39m [36mnet.sf.ehcache.distribution.RMICachePeer:180[0;39m - RMICachePeer for cache common-cache: remote put received. Element is: [ key = 2, value=2, version=1, hitCount=0, CreationTime = 1668502802000, LastAccessTime = 1668502802068 ]
2022-11-15 17:00:02.068 [RMI TCP Connection(4)-10.2.6.77] [39mDEBUG[0;39m [36mnet.sf.ehcache.distribution.RMICachePeer:180[0;39m - RMICachePeer for cache common-cache: remote put received. Element is: [ key = 3, value=3, version=1, hitCount=0, CreationTime = 1668502802000, LastAccessTime = 1668502802068 ]
2022-11-15 17:00:02.068 [RMI TCP Connection(4)-10.2.6.77] [39mDEBUG[0;39m [36mnet.sf.ehcache.distribution.RMICachePeer:180[0;39m - RMICachePeer for cache common-cache: remote put received. Element is: [ key = 4, value=4, version=1, hitCount=0, CreationTime = 1668502802000, LastAccessTime = 1668502802068 ]
2022-11-15 17:00:02.068 [RMI TCP Connection(4)-10.2.6.77] [39mDEBUG[0;39m [36mnet.sf.ehcache.distribution.RMICachePeer:180[0;39m - RMICachePeer for cache common-cache: remote put received. Element is: [ key = 5, value=5, version=1, hitCount=0, CreationTime = 1668502802000, LastAccessTime = 1668502802068 ]
2022-11-15 17:00:02.068 [RMI TCP Connection(4)-10.2.6.77] [39mDEBUG[0;39m [36mnet.sf.ehcache.distribution.RMICachePeer:180[0;39m - RMICachePeer for cache common-cache: remote put received. Element is: [ key = 6, value=6, version=1, hitCount=0, CreationTime = 1668502802000, LastAccessTime = 1668502802068 ]
2022-11-15 17:00:02.068 [pool-1-thread-1] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:57[0;39m - 获取缓存时间:2022-11-15T17:00:02.068 - key:6 -> value: 6
2022-11-15 17:00:02.069 [RMI TCP Connection(4)-10.2.6.77] [39mDEBUG[0;39m [36mnet.sf.ehcache.distribution.RMICachePeer:180[0;39m - RMICachePeer for cache common-cache: remote put received. Element is: [ key = 7, value=7, version=1, hitCount=0, CreationTime = 1668502802000, LastAccessTime = 1668502802068 ]
2022-11-15 17:00:02.069 [RMI TCP Connection(4)-10.2.6.77] [39mDEBUG[0;39m [36mnet.sf.ehcache.distribution.RMICachePeer:180[0;39m - RMICachePeer for cache common-cache: remote put received. Element is: [ key = 8, value=8, version=1, hitCount=0, CreationTime = 1668502802000, LastAccessTime = 1668502802069 ]
2022-11-15 17:00:02.069 [RMI TCP Connection(4)-10.2.6.77] [39mDEBUG[0;39m [36mnet.sf.ehcache.distribution.RMICachePeer:180[0;39m - RMICachePeer for cache common-cache: remote put received. Element is: [ key = 9, value=9, version=1, hitCount=0, CreationTime = 1668502802000, LastAccessTime = 1668502802069 ]
2022-11-15 17:00:02.069 [pool-1-thread-1] [34mINFO [0;39m [36mcom.icfcc.fcit.dp.modules.msg.test.ShareData:57[0;39m - 获取缓存时间:2022-11-15T17:00:02.069 - key:9 -> value: 9
2022-11-15 17:00:02.069 [RMI TCP Connection(4)-10.2.6.77] [39mDEBUG[0;39m [36mnet.sf.ehcache.distribution.RMICachePeer:180[0;39m - RMICachePeer for cache common-cache: remote put received. Element is: [ key = 10, value=10, version=1, hitCount=0, CreationTime = 1668502802000, LastAccessTime = 1668502802069 ]

...
缓存获取开始时间:2022-11-15T17:00:02.068-缓存获取结束时间:2022-11-15T17:00:05.033 用时:3 秒

6.测试结论

40000个元素放入缓存集群的一个节点，从另一个节点获取元素

总耗时（秒）添加一个元素平均耗时（秒）
添加40000个元素2.1540.00005385
同步40000个元素2.9650.000074125

注意：从第一元素放入观察，发现缓存同步时，第一次同步时耗时较长，耗时0.708

放入缓存时间：2022-11-15T17:00:01.360 - key:1 -> value: 1

获取缓存时间：2022-11-15T17:00:02.068 - key:1 -> value: 1

ehcache rmi 集群配置
donkeyboy001的博客
03-04 474
ehcache rmi 集群配置
本地缓存（一）ehcache/jcs/cache4j/jcs的性能测试与使用场景分析
08-11
NULL 博文链接：https://phl.iteye.com/blog/2240901
ehcache缓存测试
qq_30177469的博客
05-13 395
springboot项目。tomcat的连接池最大线程数目设置为10。用Jeter做测试，一轮并发100个请求。springboot里面的Controller会请求一个service的方法，该service中有一个打印输出。同时该service上进行了 ehcache缓存注解。那么请问service中的打印输出会打印几次？这几次打印时间节点有什么特征？ pom.xml的maven引入： <dependency> <groupId>net.sf.ehcache</
spring + ehcache 使用实例 我测试成功
热门推荐
linfanhehe的专栏
06-26 1万+
1 spring与ehcache结合使用，需要导入如下的包：ehcache ， commons-logging , cglib , asm , spring的jar包具体版本可以选择最新。   2 spring配置文件applicationContext.xml如下： [xhtml] view plaincopy xml version="1.0
使用JMH实际测试EhCache、GuavaCache和Caffeine之间的性能
zj57356498318的博客
10-11 1119
使用JMH实际测试EhCache、GuavaCache和Caffeine之间的性能 测试代码 EhCache @BenchmarkMode({Mode.AverageTime}) @OutputTimeUnit(TimeUnit.MICROSECONDS) @Warmup(iterations=3, time = 5, timeUnit = TimeUnit.MILLISECONDS) @Me...
Ehcache集群实例
07-02
7. **测试与监控**：部署并启动Ehcache集群后，可以使用Ehcache管理工具或Terracotta的管理控制台来监控集群的状态，包括节点健康、缓存统计和事件日志。 8. **性能优化**：在集群环境中，考虑缓存数据的分布策略，...
Ehcache集群使用
04-08
为了测试集群功能，你可以使用提供的 `EhCache-Cluster-Tester` 文件，它可能包含一些用于模拟并发访问和数据同步的测试工具或示例代码。 在实际应用中，还需要关注几个关键点： 1. **数据一致性**：Ehcache 提供...
ehcache集群方案
12-31
Terracotta Server Array可以监控和管理Ehcache集群，提供自动故障检测和恢复功能。 5. **缓存更新策略**：在集群环境中，当一个节点修改了缓存项，需要将这个变化通知给其他节点。Ehcache提供了几种更新策略，如`...
ehcache集群
03-23
1. **负载均衡**：Ehcache集群可以将数据分布在多个节点上，从而将负载分散到各个服务器，降低单个节点的压力。 2. **高可用性**：如果一个节点失效，其他节点仍然可以提供服务，确保系统连续运行。 3. **数据冗余**...
ehcache和memcache性能比较
08-01
ehcache和memcache性能比较
Ehcache-Redis-Tair缓存性能对比
01-06
常用缓存的对比。 主要分析ehcache radis tair间的对比。
Ehcache与redis
u014352080的专栏
10-14 1062
Ehcache 在java项目广泛的使用。它是一个开源的、设计于提高在数据从RDBMS中取出来的高花费、高延迟采取的一种缓存方案。正因为Ehcache具有健壮性（基于java开发）、被认证（具有apache 2.0 license）、充满特色（稍后会详细介绍），所以被用于大型复杂分布式web application的各个节点中。 1. 够快 Ehcache的发行有一段时长了，经过几年的努力和不
Ehcache的一个完整例子
ouyida3的专栏
04-04 5741
Ehcache的一个完整例子测试类测试驱动开发，先写测试类package com.linkage.mapp.cache;import org.junit.Test;import com.linkage.component.PageData;public class CacheTest { @Test public final void testGetValue() throws Exc
BigMemory系列文章--1.Ehcache是什么
weixin_34150503的博客
08-23 245
转载请注明出处哈:http://carlosfu.iteye.com/blog/2237511 一、Ehcache背景 1. 官方文档的解释： What is Ehcache? Ehcache is an open-source, standards-based cache for boosting performance,...
Ehcache/Redis/Tair缓存性能对比
胖头鱼
05-22 339
后面介绍的不同方式都有测试数据，这些测试数据都是在同一的测试环境下得出的测试结果： 测试机器的配置如下： 64位5核CPU, E5620 @ 2.40GHz，内存8G CDN端缓存 由于计数器的价值并不在，具体的值是多少，尤其是对一些大访问量的商品来说个位或者十位的数据并没有什么意义，所以对这些热门商品的计数器访问可以采用定时更新的办法，可以将计数器的值...
Ehcache详解
weixin_38065504的博客
04-23 8439
Ehcache是现在最流行的纯java开源框架,配置简单，结构清晰,功能强大。Ehcache特性：1）快速轻量过去几年，众多的测试表明ehcache是最快的java缓存之一，ehcache的线程机制是为大型高并发系统设计的，大量性能测试用例保证ehcache在不同版本间性能表现的一致性，很多用户都不知道他们正在用ehcache，因此不需要什么特别的配置，api易于使用，这就很容易部署上线和运行2）...
Ehcache分布式缓存及测试方法
weixin_30276935的博客
02-02 280
接到配合架构部要求配合测试需求，对EhCache 进行测试，在此之前，未接触过ehcache缓存，之前知道一些缓存，但是还真没了解过内存缓存。于是百度，看书，查资料，先恶补一下ehcache的一些知识，然后整理如下： EhCache 是一个分布式缓存，分布式缓存系统简介： Ehcache是一个纯java的进程内缓存框架，也就是说Ehcache是一个进程中的缓存系统。 Ehcache的主要特性...
Java循环编程常见错误与优化实践
最新发布
静水深流
06-10 197
值得注意的是，基础的静态分析诊断（如"变量未使用"）无法检测此类问题，因为循环变量。该实现完全封装了索引操作，消除了客户端代码中显式使用索引的风险。建议在代码审查时特别关注循环体内索引变量的使用一致性，并针对边界情况（如空数组、单元素数组、多元素同值数组）设计专项测试用例。），将导致严重的无限循环问题。在需要逆向遍历集合时，开发者常犯的关键错误是修改循环条件后忘记调整递增/递减操作。开发者在循环结构中常犯的一个典型错误是：虽然正确编写了循环结构，但在循环体内错误地使用常量索引（如。停止更新，引发无限循环。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

独行客-编码爱好者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值