如何在Java RMI中使用可序列化对象和回调方法正确模仿传递引用？

Question

I have a distributed application using java RMI and a main object(CoreApplication) that implements java.io.Serializable. Every minute, this main object is sent to a remote computer and processed on that JVM's thread pool. Since it's asynchronous, the object is processed without blocking the main thread on the Master computer.

When the CoreApplication object is finished processing on the remote thread, it invokes a call back method and is sent back to the main computer.

Here is some code of the remote machine processing a job invoked from the Master computer via RMI and the sendJob method

public void sendJob(final CoreApplication aJob) throws RemoteException{
    Runnable r = new Runnable(){
        public void run(){
            try {
                WorkResponse wr = aJob.process();
                client.coreApplicationHandler(aJob,wr); 
            }catch(RemoteException e){}
        }
    };
    workQueue.execute(r);
}

You can see client.coreApplicationHandler is the callback method to the main server and sends the CoreApplication object back with it, along with a response object.

Here is the coreApplicationHandler method code on the main machine

    public void coreApplicationHandler(CoreApplication j,WorkResponse wr){
        String ticker = j.getTickerSymbol();
        coreApplicationObjects.put(ticker, j);
        if(GlobalParameters.DEBUG_MODE){ 
            System.out.println("WORK RESPONSE IS "+wr.getMessage());
        }
    }

My question is, is replacing the CoreApplication object each time on the call back method the best way to make sure it's up-to-date for the next minute it's sent? CoreApplication is fluid and changes and the state must be preserved. I am sending it back to the Master computer, so it's state can be monitored from a central location. If I had 100 computation nodes and they didn't return their objects, it would get really messy I think to keep track of them all.

It works pretty good so far unless the job isn't processed by the time it tries to send out another and results in sending a stale object with an old state (ie, the same object as the last minute). Please comment if this doesn't make sense and I will do my best to explain it.

Answer 1

RMI is not a way to synchronize objects across a cluster. But there are tools to do just that. Look at http://www.hazelcast.com/ , for example.

If you have a cluster of computers and need synchronization then you need to use clustering via the server's tools or a third party tool.

I recommend hazelcast. It is very easy to use and will allow local clusters using fast UDP or WAN clusters using TCP socket to TCP socket.

For example Hazelcast will let you do something like this:

import com.hazelcast.core.MultiMap;
import com.hazelcast.core.Hazelcast;
import java.util.Collection;

// a live shared multimap shared across all cluster nodes
MultiMap<String, Order> mmCustomerOrders = Hazelcast.getMultiMap("customerOrders");

mmCustomerOrders.put("1", new Order ("iPhone", 340));

Thread.Sleep( 1000 );

Order order = (Order) mmCustomerOrders.get("1");

System.out.println( Order.quantity() ); // 340 ?? Nobody knows, it might have been changed

What is the output? If a cluster member changed the item "1" in the map, then you will get that value automagically. No more coding necessary….

Hope it helps

-Alex