Re: Autoboxing and Performance ?
On 8/21/2013 4:05 AM, Joerg Meier wrote:
On Tue, 20 Aug 2013 21:19:36 -0400, Eric Sosman wrote:
Nonetheless, I'm still of the opinion that autoboxing is Satan's
work. Another thread, somewhat further back, wondered why this
apparently thread-safe code wasn't thread-safe at all:
class Whatever {
private static Integer counter;
void someMethod() {
synchronized(counter) {
++counter;
...
}
}
...
}
I still don't see how that wouldn't be thread-safe, could you elaborate ?
Or are we to assume other code touches counter without being in a
synchronized(counter) block itself in this example ?
The `counter' variable is not an Integer object, but a
reference to an Integer object. The `++counter' line brings
a second Integer into the picture, and makes `counter' refer
to that new Integer instead of to the original. However, the
block is still synchronized on the first one; it doesn't
somehow magically re-synchronize on the second.
Assume `counter' points to Integer.valueOf(0) initially
(I ought to have showed the initialization in the snippet;
sorry). Then with threads T1 and T2 executing:
T1: synchronized(counter) // locks the 0 object
T1: ... now in critical section ...
T1: ++counter; // counter now points to the 1 object
T1: ... still in critical section ...
T2: synchronized(counter) // locks the *1* object
T2: ... now in critical section ...
Both T1 and T2 are now in the synchronized block simultaneously,
holding the locks of two different Integer objects.
--
Eric Sosman
esosman@comcast-dot-net.invalid