Expiry Policies

Overview

Expiry Policy specifies the amount of time that must pass before an entry is considered expired. Time can be counted from creation, last access, or modification time.

Depending on the memory configuration, the expiration policies remove entries from either RAM or disk:

In-Memory Mode (data is stored solely in RAM): expired entries are purged from RAM.
In-Memory + Native persistence: expired entries are removed from both memory and disk. Note that expiry policies remove entries from the partition files on disk without freeing up space. The space is reused to write subsequent entries.
In-Memory + External Storage: expired entries are removed from memory only (in GridGain) and left untouched in the external storage (RDBMS, NoSQL, and other databases).
In-Memory + Swap: expired entries are removed from both RAM and swap files.

To set up an expiration policy, you can use any of the standard implementations of javax.cache.expiry.ExpiryPolicy or implement your own.

Configuration

Below is an example expiry policy configuration.

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

CacheConfiguration<Integer, String> cfg = new CacheConfiguration<Integer, String>();
cfg.setName("myCache");
cfg.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.FIVE_MINUTES));

class ExpiryPolicyFactoryImpl : IFactory<IExpiryPolicy>
{
    public IExpiryPolicy CreateInstance()
    {
        return new ExpiryPolicy(TimeSpan.FromMilliseconds(100), TimeSpan.FromMilliseconds(100),
            TimeSpan.FromMilliseconds(100));
    }
}

public static void Example()
{
    var cfg = new CacheConfiguration
    {
        Name = "cache_name",
        ExpiryPolicyFactory = new ExpiryPolicyFactoryImpl()
    };

This API is not presently available for C++. You can use XML configuration.

You can also change or set Expiry Policy for individual cache operations. This policy is used for each operation invoked on the returned cache instance.


CacheConfiguration<Integer, String> cacheCfg = new CacheConfiguration<Integer, String>("myCache");

ignite.createCache(cacheCfg);

IgniteCache cache = ignite.cache("myCache")
        .withExpiryPolicy(new CreatedExpiryPolicy(new Duration(TimeUnit.MINUTES, 5)));

// if the cache does not contain key 1, the entry will expire after 5 minutes
cache.put(1, "first value");

Eager TTL

Entries that are expired can be removed from the cache either eagerly or when they are accessed by a cache operation. If there is at least one cache configured with eager TTL enabled, GridGain creates a single thread to clean up expired entries in the background.

If the property is set to false, expired entries are not removed immediately. Instead, they are removed when they are requested in a cache operation by the thread that executes the operation.

Eager TTL can be enabled or disabled via the CacheConfiguration.eagerTtl property (the default value is true):

<bean class="org.apache.ignite.configuration.CacheConfiguration">
    <property name="eagerTtl" value="true"/>
</bean>

CacheConfiguration<Integer, String> cfg = new CacheConfiguration<Integer, String>();
cfg.setName("myCache");

cfg.setEagerTtl(true);

var cfg = new CacheConfiguration
{
    Name = "cache_name",
    EagerTtl = true
};

This API is not presently available for C++. You can use XML configuration.

Resetting Expiration Timeout

You can reset expiration timeout for the cache without loading it into memory by using the cache.touch() method:

Ignite ignite = Ignition.ignite();

IgniteCache<CityKey, City> cache = ignite.cache("City").withExpiryPolicy(new TouchedExpiryPolicy(new Duration(SECONDS, 5)));

CityKey key = new CityKey(5, "NLD");

// Reset expiration timeout
cache.touch(key);

Like with most cache operations, touch can also be performed asynchronously by using the cache.touchAsync() method:

Ignite ignite = Ignition.ignite();

IgniteCache<CityKey, City> cache = ignite.cache("City").withExpiryPolicy(new TouchedExpiryPolicy(new Duration(SECONDS, 5)));

CityKey key = new CityKey(5, "NLD");

IgniteFuture<Boolean> fut = cache.touchAsync(key);

fut.listen(f -> System.out.println("Time-to-live value was " + (f.get() ? "successfully" : "not") + " updated."));

Currently, these methods have the following limitations:

Touch operations are only supported for Atomic caches.
Touch operation is guaranteed to omit loading the entry into memory for in-memory clusters only.

© 2024 GridGain Systems, Inc. All Rights Reserved. Privacy Policy | Legal Notices. GridGain® is a registered trademark of GridGain Systems, Inc.
Apache, Apache Ignite, the Apache feather and the Apache Ignite logo are either registered trademarks or trademarks of The Apache Software Foundation.

Last updated on Dec 04, 2024