do I need "volatile" for HashMap? when I apply ReentrantReadWriteLock on it.

[easy]

fomr javaoc of ReentrantReadWriteLock
an example:
class CachedData {
Object data;
volatile boolean cacheValid;
ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

void processCachedData() {
rwl.readLock().lock();
if (!cacheValid) {
.....
use(data);
rwl.readLock().unlock();
}
}
Using volatile here makes sense to me.

but if in my class looks like this,
class CachedData {
HashMap<Key, Obj> data; // <---- here
ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

void processCachedData(Key k) {
rwl.readLock().lock();
if (!data.containsKey(k)) { // <--- here
.....
use(data);
rwl.readLock().unlock();
}
}

should I declare as
"volatile HashMap"

or for which "variable" type should I apply volatile in such
situation?

thanks.

 

[Knute Johnson]

fomr javaoc of ReentrantReadWriteLock
an example:
class CachedData {
Object data;
volatile boolean cacheValid;
ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

void processCachedData() {
rwl.readLock().lock();
if (!cacheValid) {
.....
use(data);
rwl.readLock().unlock();
}
}
Using volatile here makes sense to me.

booleans used for loop control and things like that need to be volatile
only if accessed from more than one thread. In your example above that
isn't clear. In either case if your boolean were used in a synchronized
block or as in this case a locked section of code it would not need it's
own synchronization to make changes in other threads visible.

but if in my class looks like this,
class CachedData {
HashMap<Key, Obj> data; // <---- here
ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

void processCachedData(Key k) {
rwl.readLock().lock();
if (!data.containsKey(k)) { // <--- here
.....
use(data);
rwl.readLock().unlock();
}
}

should I declare as
"volatile HashMap"
No.

or for which "variable" type should I apply volatile in such
situation?

thanks.

volatile is used mainly to ensure multi-thread visibility. If you are
going to change the value of the variable in another thread and want to
see those changes then make the variable volatile. But as I said above
if the variable is only accessed inside a synchronized block or some
other synchronization code (eg ReentrantReadWriteLock) then all
variables are made visible to this thread. It is a freebie side effect.

You might want to invest a few bucks in the book "JAVA Concurrency in
Practice", by Brian Goetz. Very valuable when writing multi-threaded
Java code.

 

[easy]

great,,
thanks