Hi group,

following the various advices given by Joshua Bloch
in Effective Java, I (try to) use synchronization for
reliable communication between threads.

Such advices are:

"You may hear it said that to improve performance, you
"should avoid the use of synchronization when reading
"or writing atomic data.  This advice is dangerously
"wrong.

(which I think I understand pretty well)

or:

"The use of the volatile modifier constitutes a viable
"alternative to ordinary synchronization under certain
"circumstances, but this is an advanced technique.
"Furthermore, the extent of its applicability will not
"be known until the ongoing work on the memory model
"is complete.

(which looks more esoteric to me but forget it as of now)

So let's say I do /not/ want to use the volatile keyword.
My question is about the "synchronized" keyword, not
about "volatile".

In other words, I know that what follows can also be
done by using "volatile", but this is not related to my
question, for I'm trying to understand how
synchronization/locks are working.

Here's a short piece of code (supposed to be correctly
synchronized) shown in the book that is also seen very
often in various projects:

public void run() {
   boolean done = false;

   while (!stopRequested() && !done) {
      ...
   }
}

public synchronized void requestStop() {
   stop = true;
}

private synchronized boolean stopRequested() {
   return stop;
}

Note that there may be other synchronized methods in
the class.

So far so good, it's working fine...

But wouldn't it be more effective to create, say, a
SynchedBoolean class looking like this:

public final class SynchedBoolean {

   private boolean b;

   public SynchedBoolean(final boolean b) {
       this.b = b;
   }

   public boolean get() {
       synchronized(this) {
           return b;
       }
   }

   public void set(final boolean b) {
       synchronized(this) {
           this.b = b;
       }
   }

   ...
}

then rewrite the example with the following code:

SynchedBoolean stopRequested;

public void run() {
   boolean done = false;

   while (!stopRequested.get() && !done) {
      ...
   }
}

public synchronized void requestStop() {
   stopRequested.set(true);
}

Isn't the second example "more gentle" by
acquiring a less intrusive lock?

I suppose that performance-wise I won't see
much differences, but /technically/, is there
a difference (synchronization-wise)?

thanks a lot for any information