Re: ReadWriteLock rather on map's each field than whole map?
easy wrote:
On Sep 29, 2:15 pm, Roedy Green <see_webs...@mindprod.com.invalid>
wrote:
On Sat, 29 Sep 2007 11:37:26 -0000, easy <easy....@gmail.com> wrote,
quoted or indirectly quoted someone who said :
Can I give each "field" of map its own "ReadWriteLock"? rather than
Lock on whole map.
what if I would apply lock on "semantical" meaning?
class MyClass { // not applied with locks yet
HashMap<Key, Obj> storage;
Obj do_1(key k) {
Don't use underscores in identifiers, except for compile-time constants.
return storage.get(k);
}
void do_2(key k) {
o = storage.get(k);
if (o.notYetUpdated) {
Obj o = update(); // it's time-consuming. I want it only be
done for each key only "once".
o.setIsAlreadyUpdate();
}
storage.set(k, o);
}
}
do_1 and do_2 would be in any order with any possible key concurrently
executed.
but I want to treat any api only with the same "key" in "hand-over-
hand" w/r lock manner.
This will not work.
Since "o" is created newly from the update() method, why is it not created
"alreadyUpdated"? It's a different Obj from the one that has "notYetUpdated"
(which must be a public instance variable, a bad idiom). Or did you intend to
update a single instance of Obj? (Not a good name for a custom class, BTW.
Traditionally one uses "Foo" for examples.)
If do1 and do2 run concurrently, they will not synchronize. Updates from do2
might not be seen by callers of do1. You must establish /happens-before/ for
that to work, such as by synchronization on "storage" or the MyClass instance.
One way to do that is to build storage completely before starting the
threads that get() from it.
You will not get away with concurrent operations unless you synchronize one
way or another.
As to your goal of more fine-grained locking, your reach toward updating the
"Foo" object is in the right direction. However, you will need to synchronize
the entire test-and-set of the "updated" flag, not just the one or the other.
You do that by synchronizing on the Foo instance.
Also, since "storage" is shared data, the whole object must by synchronized
one way or another to change its structure, i.e., building it and reading it.
You can get away with unsynchronized get()s only if the Map construction
/happens-before/ all reads, i.e., before the Thread's start().
class Key
{
}
class Foo
{
private boolean updated;
public void update(){...; updated = true; }
public isUpdated() { return updated; }
}
public class Eg // instances shared among threads
{
private final Map <Key, Foo> storage =
StorageFactory.makeStorage();
@ThreadUnsafe
public Foo getSnapshot( Key key )
{
return storage.get( key );
// only sees storage.put()s from /happens-before/
}
public Foo getUpdated( Key key )
{
Foo foo = getSnapshot( key );
synchronized ( foo )
{
if ( ! foo.isUpdated() )
{
foo.update();
}
}
return foo;
}
}
--
Lew