Java Distributed Lock Manager

Sometimes you just need a simple way to coordinate activities across more than one java process. There's a lot of choices out there. The database, JMX, distributed caches, JMS, filesystems. It would be nice if there was a simple, easy way to get distributed locks in a J2SE, J2EE, Web, SOAP, or AJAX application? There is.

Terracotta provides one of the easiest ways to get a distributed lock manager in your Java application. Terracotta plugs right in to normal Java threading constructs—synchronized, wait/notify, java.concurrent.locks.ReentrantReadWriteLock, and even java.concurrent.CyclicBarrier, which means you basically already know how to use Terracotta as a lock manager.

To demonstrate, let's work up a simple locking example and then drop Terracotta in. Our app will consist of acquiring a lock, "do some work" in a simple loop, and repeat. Here's the code (LockExample.java):

public class LockExample
{
    private static Object lock = new Object();

    public static void main(String[] args) throws Exception
    {
        while (true) {
            System.out.print("Waiting for the lock..."); System.out.flush();
            synchronized (lock) {
                System.out.print("I got the lock, doing work");
                for (int i = 0; i < 4; i++) {
                    Thread.currentThread().sleep(1000);
                    System.out.print("."); System.out.flush();
                }
            }
            System.out.println("done");
       }
   }
}

Simple. If we run this on the command line, we get:

$ javac LockExample.java
$ java LockExample
Waiting for the lock...I got the lock, doing work....done
Waiting for the lock...I got the lock, doing work....done

During the "work" part the "."'s are added 1 every second for four seconds. Fancy.

Let's add Terracotta. We need a tc-config.xml file which tells Terracotta how to provide the appropriate clustering behavior to our application:

<tc:tc-config xmlns:tc="http://www.terracotta.org/config"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.terracotta.org/schema/terracotta-4.xsd">

  <application>
    <dso>
      <locks>
        <autolock>
           <method-expression>void LockExample.main(..)</method-expression>
        </autolock>
      </locks>
      <roots>
        <root>
          <field-name>LockExample.lock</field-name>
        </root>
      </roots>
    </dso>
  </application>
</tc:tc-config>

Now, let's run two JVMs with Terracotta. First, we start a server instance:

$ start-tc-server.sh
2008-12-11 22:26:18,246 INFO - Terracotta Server has started up as ACTIVE node on
  0.0.0.0:9510 successfully, and is now ready for work.

Then, we start our JVMs.

JVM 1:

$ dso-java.sh LockExample
Waiting for the lock...I got the lock, doing work....done

JVM 2:

$ dso-java.sh LockExample
Waiting for the lock...

It's a bit hard to demonstrate in a blog post, but the lock ping-pongs between the JVMs. That's it!

For more fun with distributed lock coordination, try these helpful "recipes":

• ReentrantReadWriteLock


• CyclicBarrier