Distributed Lock Service [closed]

Solution 1:

A newer kid on the block is hazelcast. I've been playing with it and it is amazingly simple to use and configure.

As far as I can see there shouldn't be any conflict between Gigaspaces and hazelcast as hazelcast doesn't have any dependencies i.e. no jgroups.jar etc

Hazelcast:

1. A mutual exclusion (lock), yep implementation of java.util.concurrency.locks.Lock
2. Automatic lock release after a certain timeout, yep all locks are released if a member leaves the cluster
3. Java implementation, yep
4. Nice to have: .Net implementation, nope is a pure java solution, might be possible to port to j#
5. If it's free: Deadlock detection / mitigation, nope no effort is made my Hazelcast to handle this
6. Easy deployment, it's a single jar with a single config file, deployed as part of your application, no additional processes are required

Solution 2:

Check out Apache's Zookeeper (A Hadoop sub-project) - it offers distributed synchronization. The documentation isn't great, but what there is makes it look an interesting product - checkout the recipes for ideas on how to use Zookeeper.

It is lower-level than you'd probably want and it does require additional deployment as it recommends dedicated servers.

You can model different locking strategies and it does offer a solution for a lock holder dying (ephemeral nodes).

Solution 3:

Teracotta, including the Open Source edition, has distributed locking semantics by using either synchronized or the java.util.concurrent.ReentrantReadWriteLock - the latter apparently fitting your requirements.

Update

Since the question now added the requirement of 'mixing' with GigaSpaces, I'm going to say don't mix them. It's just going to add more complexity to your technological stack, and the effort of:

• integrating, in terms of both code and infrastructure;
• managing synchronisation between them;
• learning/tuning/debugging Teracotta.

will be better spent creating or implementing a locking solution based on GigaSpaces.

Solution 4:

I recommend to use Redisson it's a Redis based on In-Memory Data Grid. It implements familiar Java data structures including distributed java.util.Lock and java.util.concurrent.ReentrantReadWriteLock objects. Including ability to setup leaseTime. Lock usage example:

Redisson redisson = Redisson.create(config);

Lock lock = redisson.getLock("anyLock");
try {
   // unlock automatically after 10 seconds of hold
   lock.lock(10, TimeUnit.SECONDS);

} finally {
   lock.unlock();
}

...

redisson.shutdown();

Supports cloud vendors like Azure and AWS.