ehcache 线程池使用

蔚落 2022-10-20 05:28 128阅读 0赞

--------------------

### ehcache 线程池使用 ###

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**ehcache 线程池**

**ehcache中的异步任务需要用线程池来执行，****ehcache提供了两种内置的线程池：**

**OnDemandExecutionService：**每次执行异步任务都会创建新的线程池**（默认）**

**PooledExecutionService：**预先创建的线程池，后续异步任务可重复使用

**disk store配置：**ehcache磁盘存储是异步执行

OffHeapDiskStoreConfiguration is used to configure what thread pool to use at the cache level, 
    while OffHeapDiskStoreProviderConfiguration is used to configure what thread pool to use at the cache manager level.

**OffHeapDiskStoreConfiguration：**配置在缓存上

**OffHeapDiskStoreProviderConfiguration：**配置在缓存管理器上

**Write Behind配置：**缓存异步写入后端数据库

DefaultWriteBehindConfiguration is used to configure what thread pool to use at the cache level, 
    while WriteBehindProviderConfiguration is used to configure what thread pool to use at the cache manager level.

**DefaultWriteBehindConfiguration：**配置在缓存上

**WriteBehindProviderConfiguration：**配置在缓存管理器上

**Eventing配置：**缓存监听事件通过线程池执行

DefaultCacheEventDispatcherConfiguration is used to configure what thread pool to use at the cache level, 
    while CacheEventDispatcherFactoryConfiguration is used to configure what thread pool to use at the cache manager level

**DefaultCacheEventDispatcherConfiguration：**配置在缓存上

**CacheEventDispatcherFactoryConfiguration：**配置在缓存管理器上

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**相关类与接口**

**PooledExecutionServiceConfigurationBuilder**

public class PooledExecutionServiceConfigurationBuilder implements Builder<PooledExecutionServiceConfiguration> {
    
        private PooledExecutionServiceConfigurationBuilder.Pool defaultPool;
        private final Set<PooledExecutionServiceConfigurationBuilder.Pool> pools = new HashSet();
    
    **********
    构造方法
    
        private PooledExecutionServiceConfigurationBuilder() {
        private PooledExecutionServiceConfigurationBuilder(PooledExecutionServiceConfigurationBuilder other) {
        private PooledExecutionServiceConfigurationBuilder(PooledExecutionServiceConfiguration seed) {
    
    
    **********
    其他方法
    
        public static PooledExecutionServiceConfigurationBuilder newPooledExecutionServiceConfigurationBuilder() {
        public static PooledExecutionServiceConfigurationBuilder newPooledExecutionServiceConfigurationBuilder(PooledExecutionServiceConfiguration seed) {
    
        public PooledExecutionServiceConfigurationBuilder defaultPool(String alias, int minSize, int maxSize) {
        public PooledExecutionServiceConfigurationBuilder pool(String alias, int minSize, int maxSize) {
    
        public PooledExecutionServiceConfiguration build() {
    
    
    *************
    内部类
    
        private static class Pool {
            private final String alias;
            private final int minSize;
            private final int maxSize;
    
            Pool(String alias, int minSize, int maxSize) {

### \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* ###

**示例**

public class Test4 {
    
        public static void main(String[] args){
            CacheManager cacheManager= CacheManagerBuilder.newCacheManagerBuilder()
                    .using(PooledExecutionServiceConfigurationBuilder.newPooledExecutionServiceConfigurationBuilder()
                            .defaultPool("default",5,10)
                            .pool("pool",2,6)
                            .pool("pool2",4,8)
                            .build())
                    .withDefaultDiskStoreThreadPool("default")     //默认的磁盘写入线程池
                    .withDefaultWriteBehindThreadPool("pool")      //默认的缓存数据写入线程池
                    .withDefaultEventListenersThreadPool("pool2")  //默认的事件监听线程池
                    .withCache("custom", CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class, ResourcePoolsBuilder
                            .newResourcePoolsBuilder()
                            .heap(10, MemoryUnit.MB).build())
                            .withDiskStoreThreadPool("pool2",2).build())  //缓存层面配置磁盘写入线程池
                    .withCache("custom2",CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class,ResourcePoolsBuilder
                            .newResourcePoolsBuilder()
                            .heap(10,MemoryUnit.MB)
                            .build())
                            .withLoaderWriter(new CustomLoaderWriter<>())
                            .withService(WriteBehindConfigurationBuilder
                                    .newBatchedWriteBehindConfiguration(10, TimeUnit.SECONDS,2)
                                    .useThreadPool("pool")                //缓存层面配置缓存写入线程池
                                    .build()
                            ).build())
                    .withCache("custom2",CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class,ResourcePoolsBuilder
                            .newResourcePoolsBuilder()
                            .heap(10,MemoryUnit.MB)
                            .build())
                            .withService(CacheEventListenerConfigurationBuilder.newEventListenerConfiguration(new CustomEventListener(), EventType.CREATED))
                            .withEventListenersThreadPool("pool2"))       //缓存层面配置缓存事件监听线程池
                    .build(true);
        }
    }