Standalone Ehcache

When using the Ehcache APIs in standalone ehcache core, there is no direct control over locking. The last write wins. This is akin to the READ_UNCOMMITTED isolation level.

However the using the Explicit locking API uses the lock manager which as of Ehcache 2.1, has been extended to support local caching.

Standard Ehcache clustered with Terracotta

In this case the cache is always coherent, akin to READ_COMMITTED isolation level. This package simply gives you more control over when locks are acquired and released. In regular Ehcache if you get an object to read or write it can be changed underneath you while you are performing your application level operations on the object. p/

Explicit Locking Ehcache clustered with Terracotta

With this module you can first get the lock for the key, then perform your app level operations preventing anyone else from writing to the object. When the app level operations are completed you put the Element back in the cache and release the lock so that others can now access it.

Here is a brief example:

        String key = "123";
        Foo val = new Foo();
        cache.acquireWriteLockOnKey(key);
        try {
                cache.put(new Element(key, val));
        } finally {
                cache.releaseWriteLockOnKey(key);
        }
        ...sometime later

        String key = "123";
        cache.acquireWriteLockOnKey(key);
        try {
                Object cachedVal = cache.get(key).getValue();
                cachedVal.setSomething("abc");
                cache.put(new Element(key, cachedVal));
         } finally {
           cache.releaseWriteLockOnKey(key);
         }