jcs.default=
jcs.default.cacheattributes=\
    org.apache.commons.jcs3.engine.CompositeCacheAttributes
jcs.default.cacheattributes.MaxObjects=1000
jcs.default.cacheattributes.MemoryCacheName=\
    org.apache.commons.jcs3.engine.memory.lru.LRUMemoryCache

var cache =
  JCS.<Long, String>getInstance("cache"); // 1
cache.put(1L, "One");                           // 2
var value = cache.get(1L);                      // 3
System.out.println(value);
JCS.shutdown();                                 // 4

1. Get access to the cache region
2. Put
3. Get
4. Clean up

The JCS goes beyond simply caching objects in memory. It provides numerous additional features:

• Memory management
• Disk overflow (and defragmentation)
• Thread pool controls
• Element grouping
• Minimal dependencies
• Quick nested categorical removal
• Data expiration (idle time and max life)
• Extensible framework
• Fully configurable runtime parameters
• Region data separation and configuration
• Fine grained element configuration options
• Remote synchronization
• Remote store recovery
• Non-blocking "zombie" (balking facade) pattern
• Lateral distribution of elements via HTTP, TCP, or UDP
• UDP Discovery of other caches
• Element event handling
• Remote server chaining (or clustering) and failover
• Custom event logging hooks
• Custom event queue injection
• Custom object serializer injection
• Key pattern matching retrieval
• Network efficient multi-key retrieval

var cache = CacheBuilder.newBuilder()
                        .maximumSize(1000)
                        .build()

cache.put(1L, "One");               // 1             
var value = cache.getIfPresent(1L); // 2
System.out.println(value);
cache.cleanUp();                    // 3

1. Put
2. Get
3. Clean up

• FIFO
• Weight-based eviction: One can assign a weight to each entry, according to a custom algorithm, and set the cache a weight limit. Then, if a new entry would exceed the maximum weight, the "heaviest" entries are removed until the sum of the weights is below the set threshold.

var cache = Caffeine.newBuilder()
                    .maximumSize(1000)
                    .build()

cache.put(1L, "One");                 // 1
var value = cache.getIfPresent(1L);   // 2
System.out.println(value);
cache.cleanUp();                      // 3

1. Put
2. Get
3. Clean up

var cache = Caffeine.newBuilder()
                    .maximumSize(1000)
                    .<Long, String>buildAsync();        // 1

CompletableFuture future =
    cache.get(1L, k -> expensiveLookup(1L));

1. Build an asynchronous cache

• FIFO
• Weight-based eviction: One can assign a weight to each entry, according to a custom algorithm, and set the cache a weight limit. Then, if a new entry would exceed the maximum weight, the "heaviest" entries are removed until the sum of the weights is below the set threshold.

• Automatic loading of entries into the cache, optionally asynchronously
• Size-based eviction when a maximum is exceeded based on frequency and recency
• Time-based expiration of entries, measured since last access or last write
• Asynchronously refresh when the first stale request for an entry occurs
• Keys automatically wrapped in weak references
• Values automatically wrapped in weak or soft references
• Notification of evicted (or otherwise removed) entries
• Writes propagated to an external resource
• Accumulation of cache access statistics

var cacheManager = CacheManagerBuilder
    .newCacheManagerBuilder()
    .withCache(
        "cache",
        CacheConfigurationBuilder.newCacheConfigurationBuilder(
            Long.class,
            String.class,
            ResourcePoolsBuilder.heap(10)
        )
    ).build();
cacheManager.init();
var cache = cacheManager.getCache(
    "cache", Long.class, String.class
);

cache.put(key, value);         // 1 
var value = cache.get(key);         // 2
cacheManager.close();               // 3

1. Put
2. Get
3. Clean up

• LRU
• LFU
• FIFO
• Pluggable policy: EhCache provides an API to write your own eviction policy

var cacheManager = new DefaultCacheManager();
cacheManager.defineConfiguration("cache",
    new ConfigurationBuilder().memory().maxSize("1000").build()
);
var cache = cacheManager.<Long, String>getCache("cache");

cache.put(1L, "One");               // 1
var value = cache.get(1L);          // 2
System.out.println(value);
cacheManager.close();               // 3

1. Put
2. Get
3. Clean up

CompletableFuture<String> future =
    cache.getAsync(1L, k -> expensiveLookup(1L));

LFU

• Interoperability: access data across multiple protocols and programming languages
• Resilient and Fault Tolerant Data: ensure data is always available to meet demanding workloads
• ACID Transactions: guarantee that data is always valid and consistent
• Clustered Processing: process data in real-time without burdening resources
• Queries: perform simple, accurate, and fast searches across distributed data sets

<?xml version="1.0"?>
<cache-config>
    <caching-scheme-mapping>
        <cache-mapping>
            <cache-name>cache</cache-name>
            <scheme-name>local</scheme-name>
        </cache-mapping>
    </caching-scheme-mapping>
    <caching-schemes>
        <local-scheme>
            <scheme-name>local</scheme-name>
            <high-units>1000</high-units>
        </local-scheme>
    </caching-schemes>
</cache-config>

var cache = CacheFactory.<Long, String>getCache("cache"); // 1
cache.put(1L, "One");        // 2
var value = cache.get(1L);   // 3
System.out.println(value);
cache.close();               // 4

1. Get a reference to the cache
2. Put
3. Get
4. Clean up

var cache = CacheFactory
                .<Long, String>getCache("cache")
                .async();
CompletableFuture future = cache.get(1L);

• MFU and MRU scaled on a logarithmic curve
• LRU
• LFU
• Pluggable policy: EhCache provides an API to write your own eviction policy

Commercial versions are available:

• Standard
• Enterprise
• Grid

• Clustering and Data Sharding
• Scalability and High Avalability
• Disk-Based Persistence
• Key-Value Data Store
• Parallel Queries
• Efficient Aggregation
• In-Place Processing
• Sophisticated Event Model

var cacheCfg = new CacheConfiguration<Long, String>();
cacheCfg.setOnheapCacheEnabled(true);
cacheCfg.setEvictionPolicyFactory(
    () -> new LruEvictionPolicy<>(1000)
);
cacheCfg.setName("cache");
var cfg = new IgniteConfiguration();
cfg.setCacheConfiguration(cacheCfg);
ignite = Ignition.start(cfg);
var cache = ignite.getOrCreateCache("cache");

cache.put(1L, "One");             // 1
var value = cache.get(1L);        // 2
System.out.println(value);
ignite.close();                   // 3

1. Put
2. Get
3. Clean up

IgniteFuture<String> future = cache.getAsync(1L); // 1

1. Ignite provides its own asynchronous primitives, which are different from the JDK’s

• LRU
• FIFO
• Sorted: Entries are removed in order, so that they need to implement Comparable or you need to configure you own Comparator implementation

Core features:

• Distributed SQL
• Multi-tier Storage
• Co-located Compute
• ACID Transactions
• Machine Learning
• Continuous Queries

var cache = new CacheFactory().create();
var factory = cache.<Long, String>createRegionFactory();
factory.setEvictionAttributes(
    EvictionAttributes.createLRUEntryAttributes(1000)
);
var region = factory.create("cache");

region.put(1L, "One");         // 1 
var value = region.get(1L);    // 2
System.out.println(value);
cache.close();                 // 3

1. Put
2. Get
3. Clean up

LRU

[...] main features and key functionality:

• High Read-and-Write Throughput
• Low and Predictable Latency
• High Scalability
• Continuous Availability
• Reliable Event Notifications
• Parallelized Application Behavior on Data Stores
• Shared-Nothing Disk Persistence
• Reduced Cost of Ownership
• Single-Hop Capability for Client/Server
• Client/Server Security
• Multisite Data Distribution
• Continuous Querying
• Heterogeneous Data Sharing

var hazelcast = Hazelcast.newHazelcastInstance();
hazelcast.getConfig()
         .getMapConfig("cache")
         .getEvictionConfig()
         .setSize(1000);
var map = hazelcast.getMap("cache");

map.put(1L, "One");               // 1 
var value = map.get(1L);          // 2
System.out.println(value);
hazelcast.shutdown();             // 3

1. Put
2. Get
3. Clean up

CompletionStage<String> stage = cache.getAsync(1L);

• LRU
• LFU
• Pluggable policy: Hazelcast provides an API to write your own eviction policy

• Distributed computation, data structures, and events
• Streaming data processing
• Connectors to read from/write to systems like Apache Kafka, JMS, JDBC and HDMS
• Querying with SQL and predicates
• CP subsystem for distributed coordination use cases
• JCache implementation
• Replication of web sessions (filter, Tomcat, Jetty based)
• Administration and monitoring utilities including Management Center, JMX, metrics and diagnostics