Question

I have a java threads related question.

To take a very simple example, lets say I have 2 threads.

Thread A running StockReader Class instance

Thread B running StockAvgDataCollector Class instance

In Thread B, StockAvgDataCollector collects some market Data continuously, does some heavy averaging/manipulation and updates a member variable spAvgData

In Thread A StockReader has access to StockAvgDataCollector instance and its member spAvgData using getspAvgData() method.

So Thread A does READ operation only and Thread B does READ/WRITE operations.

Questions

1. Now, do I need synchronization or atomic functionality or locking or any concurrency related stuff in this scenario? It doesnt matter if Thread A reads an older value.

2. Since Thread A is only going READ and not update anything and only Thread B does any WRITE operations, will there be any deadlock scenarios?

I’ve pasted a paragraph below from the following link. From that paragraph, it seems like I do need to worry about some sort of locking/synchronizing.

http://java.sun.com/developer/technicalArticles/J2SE/concurrency/

Reader/Writer Locks

When using a thread to read data from an object, you do not necessarily need to prevent another thread from reading data at the same time. So long as the threads are only reading and not changing data, there is no reason why they cannot read in parallel. The J2SE 5.0 java.util.concurrent.locks package provides classes that implement this type of locking. The ReadWriteLock interface maintains a pair of associated locks, one for read-only and one for writing. The readLock() may be held simultaneously by multiple reader threads, so long as there are no writers. The writeLock() is exclusive. While in theory, it is clear that the use of reader/writer locks to increase concurrency leads to performance improvements over using a mutual exclusion lock. However, this performance improvement will only be fully realized on a multi-processor and the frequency that the data is read compared to being modified as well as the duration of the read and write operations.

Which concurrent utility would be less expensive and suitable in my example?

java.util.concurrent.atomic ?

java.util.concurrent.locks ?

java.util.concurrent.ConcurrentLinkedQueue ? – In this case StockAvgDataCollector will add and StockReader will remove. No getspAvgData() method will be exposed.

Thanks
Amit

Answer 1

Well, the whole ReadWriteLock thing really makes sense when you have many readers and at least one writer… So you guarantee liveliness (you won’t be blocking any reader threads if no one other thread is writing). However, you have only two threads.

If you don’t mind thread B reading an old (but not corrupted) value of spAvgData, then I would go for an AtomicDouble (or AtomicReference, depending on what spAvgData’s datatype).

So the code would look like this

public class A extends Thread {
  // spAvgData
  private final AtomicDouble spAvgData = new AtomicDouble(someDefaultValue);

  public void run() {
    while (compute) {
     // do intensive work
     // ...
      // done with work, update spAvgData
     spAvgData.set(resultOfComputation);
    }
  }

  public double getSpAvgData() {
    return spAvgData.get();
  }
}
// --------------

public class B {
  public void someMethod() {
    A a = new A();
    // after A being created, spAvgData contains a valid value (at least the default)
    a.start();
    while(read) {
      // loll around
      a.getSpAvgData();
    }
  }
}