RMI and Threads: Calling wait() on a remote object

Question

I created a counter as a remote object.
Multiple clients are displaying the counter value.
If one of the clients increments the counter, I want the displayed counter value on every client to be updated to the new value (of the counter on the server).
Therefore every client starts a new thread to "listen" for changes of the countervalue. I wanted to call the wait() method on the remote object (the remote counter). But i think it will be called on the stub instead of on the actual remote object.
Therefore i created a extra method waitForChange() on the remote object.
public void waitForChange() throws RemoteException, InterruptedException {
     synchronized(this) {
          wait();
This method only calls the wait() method. Now I'm sure it's called on the remote object and not on the stub.
This works, but my question is: is there a better way to do this?
Code:
==========================================
The remote interface
==========================================
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface RemoteCounter extends Remote {
     void incrementCounter() throws RemoteException;
     int getCounterValue() throws RemoteException;
     void waitForChange() throws RemoteException, InterruptedException;
} ==========================================
The implementation of the remote interface
==========================================
import java.rmi.*;
import java.rmi.activation.*;
import RemoteCounter;
public class RemoteCounterImpl extends Activatable
     implements RemoteCounter {
     private static final long serialVersionUID = 1L;
     private int counter = 0;
     protected RemoteCounterImpl(ActivationID id, MarshalledObject data) throws RemoteException {
          super(id, 0);
     public void incrementCounter() throws RemoteException {
          synchronized(this) {
               counter++;
               notifyAll(); //Inform all clients of the new countervalue;
     public void waitForChange() throws RemoteException, InterruptedException {
          synchronized(this) {
               wait();
     public int getCounterValue() throws RemoteException {
          return counter;
}==========================================
A piece of code registering the remote object
==========================================
ActivationDesc desc = new ActivationDesc(agi, "RemoteCounterImpl", codebase, data);
//Register with rmid
RemoteCounter counter = (RemoteCounter)Activatable.register(desc);
// Bind the stub to a name in the registry running on 1099
Naming.bind("Counter", counter);==========================================
The panel containing a button, a label
which starts a new thread listening for
counter value changes
==========================================
import javax.swing.*;
import java.awt.Dimension;
import java.awt.event.*;
import java.rmi.*;
import org.personal.exam.services.RemoteCounter;
public class PanelCounter extends JPanel {
     private static final long serialVersionUID = 1L;
     JLabel labelX = new JLabel("Press testbutton");
     Thread t;
     RemoteCounter remoteCounter;
     public PanelCounter()     {
          try {
               jbInit();
          } catch(Exception e) {
               e.printStackTrace();
     private void jbInit() throws Exception
          this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
          this.setPreferredSize(new Dimension(450,300));
          // The securityManager is required to make is possible
          // to download classes from the server
          if (System.getSecurityManager() == null) {
               System.setSecurityManager(new RMISecurityManager());
          //Create a testButton to increment the counter          
          JButton testButton = new JButton("Increment");
          testButton.addActionListener(new ActionListener(){
               public void actionPerformed(ActionEvent arg0) {
                    incrementCounter();
          this.add(testButton);
          //Add a label to display the counter value
          this.add(labelX);
          // Create thread to listen for counter value changes
          try {
               remoteCounter = (RemoteCounter)Naming.lookup("Counter");
               CounterValueChecker cvl = new CounterValueChecker(labelX, remoteCounter);
               //Start a thread to listen for changes of the countervalue
             t = new Thread(cvl);
             t.start();
          } catch(Exception e) {
               e.printStackTrace();
          this.setVisible(true);
     private void incrementCounter() {
          String message = "error";
          try {
               remoteCounter.incrementCounter();
               message = "Current value is " + remoteCounter.getCounterValue();
          } catch(Exception e) {
               System.out.println("Test Exception: " + e.getMessage());
               e.printStackTrace();
          labelX.setText(message);
}==========================================
The runnable implementation used by the
thread to wait for counterchanges
==========================================
import java.rmi.RemoteException;
import javax.swing.JLabel;
import org.apache.log4j.Logger;
import RemoteCounter;
public class CounterValueChecker implements Runnable {
     private JLabel counterLabel;
     private RemoteCounter remoteCounter;
     public boolean keepChecking= true;
     private Logger logger = Logger.getLogger(this.getClass());
     public CounterValueChecker(JLabel counterLabel, RemoteCounter remoteCounter){
          this.counterLabel = counterLabel;
          this.remoteCounter = remoteCounter;
     public void run() {
          while(keepChecking) {
               int newVal = -1;
               synchronized(remoteCounter) {
                    try {
                         //remoteCounter.wait();
//this does not work. I think because the wait() method is called on the
//stub instead of on the actual remote object
                         remoteCounter.waitForChange();
                    } catch (InterruptedException e) {
                         keepChecking = false;
                         break;
                    } catch (RemoteException re) {
                         re.printStackTrace();
                    try {
                         newVal = remoteCounter.getCounterValue();
                    } catch (RemoteException re) {
                         re.printStackTrace();
                    counterLabel.setText("New value: " + newVal);
}This is just a little test. Actually I want to notify clients of changes in data displayed in a Table. If one client saves one record of the data, i want the new record to be displayed immediatly on all clients that are viewing the same data.

Answer 1

I've been doing some reading about RMI and callback.
As I understand it, there's a remote object is running on the client now as wel. And the server makes a call to the client.
But now the server makes a call to one client.
And the point is, I want all clients to be updated with the new value.
Does this mean, I have to keep a list with references to all clients connected to the server?
I my code the notifyAll() method causes all waiting Threads (running on several clients) to wake up and do something (getting the new counter value).