A List of Cache Providers

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

1. Put
2. Get
3. Clean up

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

• 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

• 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

[...] 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