Question

The following is a simplified version of my current code. I am pretty sure I am not doing any thing wrong syntax-wise, and I can’t locate my conceptual mistake.

This is sort of an observer pattern I tried to implement. I could not afford to inherit from Java.utils.observable as my class is already complicated and inherits from another class.
There are two parts here:

There’s a Notifier class implementing Runnable :

public class Notifier implements Runnable{

    public void run()
    {
        while(true)
        {
            MyDataType data = getData();
            if(data.isChanged()==true)
            {
                refresh();
            }
        }
    }
}

And then there is my main class which needs to respond to changes to MyDataType data.

public class abc {

    private MyDataType data;

    public void abc(){
               Notifier notifier = new Notifier();
               Thread thread = new Thread(notifier);
               thread.start();
          }     


    public MyDataType getData(){
              return this.data;
    }


    public void refresh(){
         MyDatatype data = getData();
     //Do something with data
    }
}

The problem : What’s happening is that the notifier is calling refresh() when ‘data’ changes. However inside refresh(), when I do getData(), I am getting the old version of ‘data’!
I should mention that there are other parts of the code which are calling the refresh() function too.

• What am I overlooking?
• Any other better solutions to this problem?
• How should I approach designing Subject-Observer systems if I can’t apply the default Java implementation out of the box?

Answer 1

First, your data variable might be cached, so you will always need to get the latest value by making it volatile.

Second, what you are doing here is a producer / consumer pattern. This pattern is usually best implemented with messages. When you receive new data, you could create an immutable object and post it to the consumer thread (via a thread safe queue like a BlockingQueue) instead of having a shared variable.

Something along these lines:

public class Notifier extends Thread{
   private BlockingQueue<E> consumerQueue = null;
   public setConsumerQueue(BlockingQueue<E> val){
      consumerQueue = val;
   }
   // main method where data is received from socket...
   public void run(){
      while(!interrupted()){
           data = ... // got new data here
           if(!data.isChanged()) continue;
           // Post new data only when it has changed
           if(consumerQueue!=null) consumerQueue.offer(data);
      }
   }
}

public class Consumer extends Thread{
   private BlockingQueue<E> consumerQueue = new BlockingQueue<E>();
   public Consumer (Producer val){
      val.setConsumerQueue(consumerQueue);
   }
   public void run(){
      while(!interrupted()){
           data = consumerQueue.take();// block until there is data from producer
           if(data !=null) processData(data);
      }
   }
}