Issue with wait/notify

[Will Myers]

Hi,
I'm trying to get some code working which should do something like loop through a list of tradeIds and add a value for each trade if it doesn't have one, do nothing if it has been processed, and wait if it is being currently processed then wake up and continue.

My code looks like:

Trade class

public class Trade {

	/**
	 * Status can be 0 (Unprocessed), 1 (Processing), or 2 (Processed)
	 */
	private volatile int status = 0;
	private final int tradeId;
	private volatile int value = 0;
	private final String counterparty;

	public Trade(int tradeId, String counterparty) {
		super();
		this.tradeId = tradeId;
		this.counterparty = counterparty;
	}

	public int getStatus() {
		return status;
	}

	public void setStatus(int status) {
		this.status = status;
	}

	public int getTradeId() {
		return tradeId;
	}

	public int getValue() {
		return value;
	}

	public void setValue(int value) {
		this.value = value;
	}

	public String getCounterparty() {
		return counterparty;
	}

}

the thread:

public class ProcessorThread implements Runnable {

	// map of trades
	private volatile ConcurrentHashMap<Integer, Trade> map;
	// list of trades to process
	private List<Integer> trades;

	public ProcessorThread(ConcurrentHashMap<Integer, Trade> map,
			List<Integer> trades) {
		super();
		this.map = map;
		this.trades = trades;
	}

	@Override
	public void run() {

		for (Integer trade : trades) {
			while (map.get(trade).getStatus() != 2) {
				synchronized (this) {
					switch (map.get(trade).getStatus()) {
					case 0:
						System.out.println(Thread.currentThread().getId()
								+ ": Process" + map.get(trade).getTradeId());
						// process the trade
						processTrade(map.get(trade));
						// notify other threads that may be waiting
						notifyAll();
						break;
					case 1:
						System.out.println(Thread.currentThread().getId()
								+ ": Wait" + map.get(trade).getTradeId());
						// trade is processing so wait
						try {
							wait();
						} catch (InterruptedException e) {
						}
						break;
					case 2:
						System.out.println(Thread.currentThread().getId()
								+ ": Do Nothing" + map.get(trade).getTradeId());
						// don't do anything as we have already processed it
						break;
					}
				}
			}
		}

	}

	private boolean processTrade(Trade t) {
		t.setStatus(1);
		// just wait a random amount of time
		Random random = new Random();
		try {
			Thread.sleep(random.nextInt(5000));
		} catch (InterruptedException e) {
		}
		t.setValue(100);
		t.setStatus(2);
		return true;
	}

}

and the main method class

public class Main {

	//map of trades
	private volatile ConcurrentHashMap<Integer, Trade> map = new ConcurrentHashMap<Integer, Trade>();
	private List<Integer> trades = new ArrayList<Integer>();
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Main process = new Main();
		process.setUp();
		
		//runnables
		ProcessorThread pt1 = new ProcessorThread(process.map, process.trades);
		ProcessorThread pt2 = new ProcessorThread(process.map, process.trades);
		ProcessorThread pt3 = new ProcessorThread(process.map, process.trades);

		//threads
		Thread t1 = new Thread(pt1);
		Thread t2 = new Thread(pt2);
		Thread t3 = new Thread(pt3);
		
		t1.start();
		t2.start();
		t3.start();
	}

	private void setUp(){
		for (int i = 0; i < 100; i++) {
			Trade t = new Trade(i, "Trade Number " + i);
			map.put(i, t);
			trades.add(i);
		}
	}

}

the problem I'm having is that once a thread goes to sleep it never wakes up, I'm calling notifyAll after a trade is processed but nothing happens. This is probably an embarrasing schoolboy error but I'm stumped!

Thanks
Willy

[Henry Wong]

will myers wrote:
the problem I'm having is that once a thread goes to sleep it never wakes up, I'm calling notifyAll after a trade is processed but nothing happens. This is probably an embarrasing schoolboy error but I'm stumped!

You are using the "this" object for notification, which is the runnable instance for the thread. If you look at your init code, you will see that the three thread have different runnable instances. IOWs, the three threads are using different synchronization and notification objects.

Henry

[Will Myers]

Thanks Henry, I knew it was something dumb!