Cluster Shared Cache [closed]

Question

I am searching for a java framework that would allow me to share a cache between multiple JVMs.

What I would need is something like Hazelcast but without the "distributed" part. I want to be able to add an item in the cache and have it automatically synced to the other "group member" cache. If possible, I'd like the cache to be sync'd via a reliable multicast (or something similar).

I've looked at Shoal but sadly the "Distributed State Cache" seems like an insufficient implementation for my needs.

I've looked at JBoss Cache but it seems a little overkill for what I need to do.

I've looked at JGroups, which seems to be the most promising tool for what I need to do. Does anyone have experiences with JGroups ? Preferably if it was used as a shared cache ?

Any other suggestions ?

Thanks !

EDIT : We're starting tests to help us decide between Hazelcast and Infinispan, I'll accept an answer soon.

EDIT : Due to a sudden requirements changes, we don't need a distributed map anymore. We'll be using JGroups for a low level signaling framework. Thanks everyone for you help.

Answer 1

How about this?

Have a local ConcurrentHashMap as your local cache. Create a Hazelcast distributed map/cache. Start listening for the distributed map events and update your local ConcurrentHashMap.

Now local caches on each member will be the same. Auto-synched.

import com.hazelcast.core.IMap; 
import com.hazelcast.core.Hazelcast;
import com.hazelcast.core.EntryListener;
import com.hazelcast.core.EntryEvent; 
import java.util.concurrent.ConcurrentHashMap;

public class Sample implements EntryListener {
        Map localCache = new ConcurrentHashMap ();

        public static void main(String[] args) { 
                Sample sample = new Sample();
                IMap   map    = Hazelcast.getMap("default"); 

                //Listen for all added/updated/removed entries
                map.addEntryListener(sample, true);  
        }

        public void entryAdded(EntryEvent event) {
             localCache.put(event.getKey(), event.getValue());            
        }

        public void entryRemoved(EntryEvent event) {
             localCache.remove(event.getKey());            
        }

        public void entryUpdated(EntryEvent event) {
             localCache.put(event.getKey(), event.getValue());            
        }
}

Answer 2

Have you considered Infinispan - http://www.jboss.org/infinispan/ ? The API is very simple and based on a standard (JSR-107). The usage is also very simple

CacheManager manager = new DefaultCacheManager(
                GlobalConfiguration.getClusteredDefault() );

Cache cache = manager.getCache();

cache.put("key", "value");

--Hardy

Answer 3

After some more searching, I found JGroup's ReplicatedHashMap. It has not been thoroughly tested but it seems like an excellent start. It fills all my requirements without giving me too much features I don't need. It's also quite flexible. I'm still searching for the "perfect" answer though :)

Thanks for your answers.

Answer 4

Have you considered Terracotta? Might be overkill: http://www.terracotta.org/web/display/orgsite/Data+Caching

There was a JSR in the area of caching a while ago, do any of the following fit the bill: http://java-source.net/open-source/cache-solutions/jcache ?

I personally used FKache a few years ago and it worked well, but I didn't use it in distributed mode.

Is it important that it's a distributed cache with local copies of data? There's also the JavaSpaces stuff if it's shared memory you need...

Answer 5

I've used a few technologies in this area, I can highly recommend JBoss Cache as the best choice for what you're trying to do. It uses JGroups as its transport, but provides a higher-level transactional abstraction. Out-of-the-box it gives you a distributed tree-node structure.

edit: Oh, and JBossCache is independent of JBoss Application Server, you can use it in any environment. If anything, it works better outside of JBossAS than it does inside it.

Answer 6

Memcached has several Java Clients.

Answer 7

My option is Java Caching System from Apache, it has support of TCP Lateral Cache which in my opinion is the feature you need.

Answer 8

http://ehcache.org/ is very good and light cache. It can be shared between multiple JVMs. Internally it can use JGroups.