Stupid Simple JVM Coordination

If you think cross-jvm coordination is easy - then this post is not for you. If it makes you cringe inside, just trying to remember the JMS interfaces, or JGroups api, java.io classes, or figuring out how to mess with a database, then carry on, intrepid reader. This post is for you.

I'm going to show you how stupid simple it is to use Terracotta to send a message from one JVM to the other. We'll use two JVMs - a producer and a consumer. I want the producer to create and send a message to the consumer. I want the producer to wait for the consumer to consume the message. When the message is consumed I want the producer to use the return value from the consumer.

This would be stupid hard if it weren't for two amazing technologies. The first is the java.util.concurrent package. The second is Terracotta JVM Level Clustering. Putting them together gives you stupid simple JVM coordination.

The scenario I outlined is actually ridiculously easy in a single JVM using the java.util.concurrent package. It was built to handle these scenarios and more at the flick of a wrist. Instantiate a queue, fire off a couple of threads, use a FutureTask, and you're done.

And you know what? Could it get any more simple than writing one line of code to cluster that queue, and move from two threads in one JVM to one thread in two JVMs. It can't.

Here's the main method that does it all:

public class Main
{
   public static final Main instance = new Main();

   private AtomicInteger counter = new AtomicInteger(0);
   private BlockingQueue<FutureTask> queue = new LinkedBlockingQueue<FutureTask>();

   public void listen() throws InterruptedException
   {
       while (true) {
           queue.take().run();
       }
   }

   public void run() throws Exception
   {
       if (counter.getAndIncrement() == 0) {
           System.out.println("Waiting...");
           listen();
           return;
       }
     
       FutureTask task = new FutureTask(new MyCallable());
       queue.put(task);
       System.out.println("Task completed at: " + task.get().toString());
   }

   private static class MyCallable implements Callable
   {
        public Object call() throws InterruptedException
        {
            System.out.println(new Date().toString() + ": Sleeping 2 seconds...");
            Thread.sleep(2000);
            System.out.println("Hello world");

            return new Date();
        }
   }

   public static void main(String[] args) throws Exception
   {
       instance.run();
   }
}

And the Terracotta config:

<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>
      <instrumented-classes>
        <include>
          <class-expression>Main$MyCallable</class-expression>
        </include>
      </instrumented-classes>
     <roots>
       <root>
         <field-name>Main.instance</field-name>
       </root>
     </roots>
   </dso>
 </application>
</tc:tc-config>

That's all there is to it. Output looks like this:

Node 1:

$ javac *.java
$ start-tc-server &
$ dso-java Main
Waiting...
(after starting other node...)
Mon Mar 17 17:53:45 PDT 2008: Sleeping 2 seconds...
Hello world

Node 2:

$ dso-java Main
Task completed at: Mon Mar 17 17:53:47 PDT 2008

I've actually written this entire example up as a Recipe on Terracotta.org. Full details and instructions are listed there in the FutureTask recipe.