Collection concurreny issue

Question

Hi
I have an issue with probably concurrency. Look at the code below:
import java.util.HashMap;
import java.util.LinkedList;
public class TestStressMarketPriceUpdateProcessor {
  ObjectQueue objectQueue = new ObjectQueue();
  UpdateProcessor uP;
  class UpdateProcessor extends Thread {
    UpdateProcessor() {
      super("UpdateProcessor");
    public void run() {
      while (true) {
        Object o = objectQueue.getLastObject();
  class Updater extends Thread {
    Object lock = new Object();
    String num;
    public Updater(int num) {
      super("Updater " + num);
      this.num = String.valueOf(num);
    public void run() {
      while (true) {
        synchronized (lock) {
          try {
            lock.wait(1);
          } catch (InterruptedException e) {
            e.printStackTrace();
        objectQueue.putObject(new Object(), num);
  public class ObjectQueue {
    HashMap<String, Object> map;
    LinkedList<Object> list;
    Object lock;
    public ObjectQueue() {
      map = new HashMap<String, Object>(60, 0.9f);
      list = new LinkedList<Object>();
      lock = new Object();
    public void putObject(Object obj, String key) {
      synchronized (lock) {
        Object prevObj = map.get(key);
        list.remove(prevObj);
        map.put(key, obj);
        list.add(obj);
        lock.notify();
    public Object getLastObject() {
      synchronized (lock) {
        if (list.isEmpty()) {
          try {
            lock.wait();
          } catch (InterruptedException ex) {
            return null;
        Object lastObject = list.removeFirst();
        map.values().remove(lastObject);
        return lastObject;
  public TestStressUpdateProcessor() {
    uP = new UpdateProcessor();
    uP.start();
    int num = 50;
    for (int i = 0; i < num; i++) {
      (new Updater(i)).start();
  public final static void main(String args[]) {
    new TestStressUpdateProcessor();
}What i experience is that sometimes the removeFirst() method throws a NoSuchElementException.
In the first place i cant see how could that happen, since only synchronized block can remove elements in the code.
I also suspected memory concurrency issue, but no matter volatile, or synchronized List, the issue still happens sometimes.
Can anyone help show my whats the flaw in the code?
thanx
david

Answer 1

matra,
As I can see from you code, there is a main thread (TestStressMarketPriceUpdateProcessor) which tries continously to get object from the ObjectQueue
the ObjectQueue is another thread which is very fine.
There is another thread which is an updater thread. This thread populate the ObjectQueue.
All of the above leads up to a common resource which is ObjectQueue
The updater wait is too short which make the ObjectQueue always get populated and does not allow ObjectQueue to wait some time so I would do the following to the code ; I am not going to explain the changes; however, you can look and notice the changes by your self.
Please notice the while loop in the method getLastObject()
public class TestStressMarketPriceUpdateProcessor {
  ObjectQueue objectQueue = new ObjectQueue();
  UpdateProcessor uP;
  UpdateProcessor uP2;
  class UpdateProcessor extends Thread {
    UpdateProcessor(int updaterNum) {
      super("UpdateProcessor" + updaterNum);
    public void run() {
      while (true) {
             * No need to synchronize the  objectQueue
             * since the  objectQueue.getLastObject() is synchronized
           //synchronized(objectQueue) {
                Object o = objectQueue.getLastObject();
  } // UpdateProcessor
  class Updater extends Thread {
    String num;
    public Updater(int num) {
      super("Updater " + num);
      System.out.println("Updater-->" + num);
      this.num = String.valueOf(num);
    public void run() {
      while (true) {
        synchronized (objectQueue) {
          try {
              objectQueue.wait(1000); // give a chanc to wait sometime
               objectQueue.putObject(new Object(),num);
               objectQueue.notify();
          } catch (InterruptedException e) {
            e.printStackTrace();
  } // Updater
  public class ObjectQueue {
    HashMap<String, Object> map;
    LinkedList<Object> list;
    public ObjectQueue() {
      map = new HashMap<String, Object>(60, 0.9f);
      list = new LinkedList<Object>();
    public void putObject(Object obj, String key) {
      synchronized (this) {
        Object prevObj = map.get(key);
        list.remove(prevObj);
        map.put(key, obj);
        list.add(obj);
    public Object getLastObject() {
      synchronized (this) {
         while(list.isEmpty())  {
              System.out.println("I am empty I will wait....;Thread-->" + Thread.currentThread().getName());
          try {
            this.wait();
            System.out.println("wake up to check if I am empty");
          } catch (InterruptedException ex) {
               // Restore the interrupted status
              Thread.currentThread().interrupt();
         System.out.println("I am NOT empty....;Thread-->" + Thread.currentThread().getName());
         System.out.println("list size before-->" + map.size());
         Object lastObject = list.removeFirst();
        map.values().remove(lastObject);
        System.out.println("list size after-->" +list.size());
        return lastObject;
  public TestStressMarketPriceUpdateProcessor() {
    uP = new UpdateProcessor(1);
    uP.start();
    uP2 = new UpdateProcessor(2);
    uP2.start();
    int num = 5; // give a chance to see empty list
    for (int i = 0; i < num; i++) {
      new Updater(i).start();
  public final static void main(String args[]) {
    new TestStressMarketPriceUpdateProcessor();
}Regards,
Alan Mehio
London, UK