Java ApacheIgnite2.x-我是否可以利用堆外存储，并且仍然可以进行基于时间的逐出（从堆上和堆外存储）？

我使用的是ApacheIgnite2.8.1

我有一个特定的缓存，需要存储在堆外（因为否则我会受到内存不足的困扰）。我还需要分发缓存

但我还需要一个基于时间的逐出策略来逐出开/关内存缓存中的条目

这在ApacheIgnite2.x中可能吗

请参见此处的代码片段。我尝试过以各种方式进行配置，但除了手动操作外，没有任何操作会将这些条目从缓存中逐出

当我运行下面的

test

方法时，所有条目都保留在缓存中

import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;

import javax.cache.expiry.CreatedExpiryPolicy;
import javax.cache.expiry.Duration;

import org.apache.ignite.Ignite;
import org.apache.ignite.Ignition;
import org.apache.ignite.cache.CacheAtomicityMode;
import org.apache.ignite.cache.CacheMode;
import org.apache.ignite.cache.eviction.lru.LruEvictionPolicyFactory;
import org.apache.ignite.configuration.CacheConfiguration;
import org.apache.ignite.configuration.DataRegionConfiguration;
import org.apache.ignite.configuration.DataStorageConfiguration;
import org.apache.ignite.configuration.IgniteConfiguration;
import org.apache.ignite.configuration.NearCacheConfiguration;
import org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi;
import org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder;
    
public class IgniteCache {
    private static final String ORG_CACHE = IgniteCache.class.getSimpleName() + "Organizations";

    private static Ignite ignite;
    
    private static org.apache.ignite.IgniteCache cache;
    
    public void start() {

        IgniteConfiguration igniteConfiguration = new IgniteConfiguration();
        DataStorageConfiguration dsCfg = new DataStorageConfiguration();
        DataRegionConfiguration dfltDataRegConf = new DataRegionConfiguration();
        dfltDataRegConf.setPersistenceEnabled(true);
        dsCfg.setDefaultDataRegionConfiguration(dfltDataRegConf);
        dsCfg.setStoragePath("E:\\igniteStorage");
        igniteConfiguration.setDataStorageConfiguration(dsCfg);

        TcpDiscoverySpi tcpDiscoverySpi = new TcpDiscoverySpi();
        TcpDiscoveryVmIpFinder ipFinder = new TcpDiscoveryVmIpFinder();
        ipFinder.setAddresses(Arrays.asList("127.0.0.1:47500..47509"));
        tcpDiscoverySpi.setIpFinder(ipFinder);

        igniteConfiguration.setDiscoverySpi(tcpDiscoverySpi);

        ignite = Ignition.start(igniteConfiguration);
        
        ignite.active(true);

        CacheConfiguration<Long, X12File> cacheCfg = new CacheConfiguration<>(ORG_CACHE);

        cacheCfg.setCacheMode(CacheMode.REPLICATED);
        cacheCfg.setAtomicityMode(CacheAtomicityMode.ATOMIC);
        cacheCfg.setBackups(1);
        
        cacheCfg.setEvictionPolicyFactory(new LruEvictionPolicyFactory<>(50000, 40, 5050)); // this doesn't do anything.
        cacheCfg.setNearConfiguration(
                new NearCacheConfiguration<Long, X12File>()
                .setNearEvictionPolicyFactory(new LruEvictionPolicyFactory<>(1_000_000))); // this doesn't do anything.
        
        cache = ignite.getOrCreateCache(cacheCfg);      
        
        for (long i = 0; i < 4_000_000; i++) {
            if (i > 0 && i % 10_000 == 0) {
                System.out.println("Done: " + i);
            }
            cache.withExpiryPolicy(new CreatedExpiryPolicy(new Duration(TimeUnit.SECONDS, 1))) // this expiry policy doesn't do anything
                .put(i, new X12File("x12file" + i, LocalDateTime.now().toString()));
        }
    }
    
    public void test() {
        System.out.println("Checking if cache entries are being properly evicted ...");

        int matches = 0;
        for (long i = 0; i < 4_000_000; i++) {
            if (cache.get(i) != null) {
                ++matches;
            }
        }
        System.out.println("Matches: " + matches);
    }   
}

import java.time.LocalDateTime；
导入java.util.array；
导入java.util.concurrent.TimeUnit；
导入javax.cache.expiry.CreatedExpiryPolicy；
导入javax.cache.expiry.Duration；
导入org.apache.ignite.ignite；
导入org.apache.ignite.Ignition；
导入org.apache.ignite.cache.CacheAtomicityMode；
导入org.apache.ignite.cache.CacheMode；
导入org.apache.ignite.cache.execution.lru.LruEvictionPolicyFactory；
导入org.apache.ignite.configuration.CacheConfiguration；
导入org.apache.ignite.configuration.DataRegionConfiguration；
导入org.apache.ignite.configuration.DataStorageConfiguration；
导入org.apache.ignite.configuration.ignite配置；
导入org.apache.ignite.configuration.NearCacheConfiguration；
导入org.apache.ignite.spi.discovery.tcp.TcpDiscoverySpi；
导入org.apache.ignite.spi.discovery.tcp.ipfinder.vm.TcpDiscoveryVmIpFinder；
公共类缓存{
私有静态最终字符串ORG_CACHE=IgniteCache.class.getSimpleName（）+“Organizations”；
私人静电点火；
私有静态org.apache.ignite.IgniteCache缓存；
公开作废开始（）{
IgniteConfiguration IgniteConfiguration=新IgniteConfiguration（）；
DataStorageConfiguration dsCfg=新的DataStorageConfiguration（）；
DataRegionConfiguration dfltDataRegConf=新的DataRegionConfiguration（）；
dfltDataRegConf.setPersistenceEnabled（true）；
setDefaultDataRegionConfiguration（dfltDataRegConf）；
设置存储路径（“E:\\igniteStorage”）；
igniteConfiguration.setDataStorageConfiguration（dsCfg）；
TcpDiscoverySpi TcpDiscoverySpi=新的TcpDiscoverySpi（）；
TcpDiscoveryVmIpFinder ipFinder=新的TcpDiscoveryVmIpFinder（）；
ipFinder.setAddresses（Arrays.asList（“127.0.0.1:47500..47509”）；
tcpDiscoverySpi.setIpFinder（ipFinder）；
igniteConfiguration.setDiscoverySpi（tcpDiscoverySpi）；
点火=点火。启动（点火配置）；
点燃。激活（真）；
CacheConfiguration cacheCfg=新的CacheConfiguration（组织缓存）；
cacheCfg.setCacheMode（CacheMode.REPLICATED）；
cacheCfg.setAtomicityMode（CacheAtomicityMode.ATOMIC）；
3.挫折（1）；
cacheCfg.setexecutionpolicyFactory（新的LruEvictionPolicyFactory（50000，405050））；//这不起任何作用。
cacheCfg.setNearConfiguration(
新的NearCacheConfiguration（）
.setNearReceivectionPolicyFactory（新的LruEvictionPolicyFactory（1_000_000））；//这没有任何作用。
cache=ignite.getOrCreateCache（cacheCfg）；
对于（长i=0；i<4_000；i++）{
如果（i>0&&i%10_000==0）{
System.out.println（“完成：+i”）；
}
cache.withExpiryPolicy（新的CreatedExpiryPolicy（新的持续时间（TimeUnit.SECONDS，1））//此过期策略不起任何作用
.put（i，新X12文件（“X12文件”+i，LocalDateTime.now（）.toString（））；
}
}
公开无效测试（）{
System.out.println（“检查缓存项是否被正确逐出…”）；
int匹配=0；
对于（长i=0；i<4_000；i++）{
if（cache.get（i）！=null）{
++火柴；
}
}
System.out.println（“匹配项：+匹配项”）；
}   
}

在我的特定用例中，这只是Apache Ignite 2.x的一个缺点吗？

简而言之：

• 逐出是基于内存的。删除一些记录，因为我有太多的行或它使用了太多的空间
• 过期是基于时间的。此记录在指定的时间段内未被触摸，因此应将其删除

所有缓存都脱离堆。您可以对缓存进行如下配置：

<bean class="org.apache.ignite.configuration.CacheConfiguration">
    <property name="name" value="myCache"/>
    <property name="expiryPolicyFactory">
        <bean class="javax.cache.expiry.CreatedExpiryPolicy" factory-method="factoryOf">
            <constructor-arg>
                <bean class="javax.cache.expiry.Duration">
                    <constructor-arg value="MINUTES"/>
                    <constructor-arg value="5"/>
                </bean>
            </constructor-arg>
        </bean>
   </property>
</bean>

（近堆/堆上缓存确实起到了一定的作用。这不是您所期望的！它们都在堆上，并且在堆外缓存之外工作。）

简而言之：

• 逐出是基于内存的。删除一些记录，因为我有太多的行或它使用了太多的空间
• 过期是基于时间的。此记录在指定的时间段内未被触摸，因此应将其删除

所有缓存都脱离堆。您可以对缓存进行如下配置：

<bean class="org.apache.ignite.configuration.CacheConfiguration">
    <property name="name" value="myCache"/>
    <property name="expiryPolicyFactory">
        <bean class="javax.cache.expiry.CreatedExpiryPolicy" factory-method="factoryOf">
            <constructor-arg>
                <bean class="javax.cache.expiry.Duration">
                    <constructor-arg value="MINUTES"/>
                    <constructor-arg value="5"/>
                </bean>
            </constructor-arg>
        </bean>
   </property>
</bean>

---

（近堆/堆上缓存确实起到了一定作用。这与您的预期不同！它们都在堆上，并且在堆外缓存之外工作。）

正如我从您的代码和解释中所理解的，您似乎对逐出策略和过期策略有点困惑

逐出策略确定在RAM耗尽时应从RAM中删除哪些数据

用于确定缓存项TTL的到期策略

在您的情况下，您只需要到期策略。看看我的例子：

private static final String ORG_CACHE = IgniteCache.class.getSimpleName() + "Organizations";

public static void main(String[] args) throws Exception {
    DataRegionConfiguration dfltDataRegConf = new DataRegionConfiguration();
    dfltDataRegConf.setPersistenceEnabled(true);

    DataStorageConfiguration dsCfg = new DataStorageConfiguration();
    dsCfg.setDefaultDataRegionConfiguration(dfltDataRegConf);
    dsCfg.setStoragePath("/home/kazakov/tmp");

    IgniteConfiguration igniteConfiguration = new IgniteConfiguration();
    igniteConfiguration.setDataStorageConfiguration(dsCfg);

    TcpDiscoverySpi tcpDiscoverySpi = new TcpDiscoverySpi();
    TcpDiscoveryVmIpFinder ipFinder = new TcpDiscoveryVmIpFinder();
    ipFinder.setAddresses(Arrays.asList("127.0.0.1:47500..47509"));
    tcpDiscoverySpi.setIpFinder(ipFinder);

    igniteConfiguration.setDiscoverySpi(tcpDiscoverySpi);

    try(Ignite ignite = Ignition.start(igniteConfiguration)) {
        ignite.active(true);

        CacheConfiguration<Long, X12File> cacheCfg = new CacheConfiguration<>(ORG_CACHE);

        cacheCfg.setCacheMode(CacheMode.REPLICATED);
        cacheCfg.setAtomicityMode(CacheAtomicityMode.ATOMIC);
        cacheCfg.setBackups(1);
        cacheCfg.setOnheapCacheEnabled(true);

        IgniteCache<Long, X12File> cache = ignite.getOrCreateCache(cacheCfg).withExpiryPolicy(new CreatedExpiryPolicy(new Duration(TimeUnit.SECONDS, 1)));

        for (long i = 0; i < 4_000_000; i++) {
            if (i > 0 && i % 10_000 == 0)
                System.out.println("Done: " + i);

            cache.put(i, new X12File("x12file" + i, LocalDateTime.now().toString()));
        }

        Thread.sleep(5000);

        int matches = 0;
        for (long i = 0; i < 4_000_000; i++) {
            if (cache.get(i) != null)
                ++matches;
        }
        System.out.println("Matches: " + matches);
    }
}

private静态最终字符串ORG\u CACHE=IgniteCache.class.getSimpleName（）+“Organizations”；
公共静态void main（字符串[]args）抛出