Exactly--it's the version of the UniqueHash that *is* thread-safe.  The
original, where I merely set hashCode = id++, was not thread safe.

Walter Gildersleeve
Freiburg, Germany

______________________________________________________
http://linkfrog.net
URL Shortening
Free and easy, small and green.

Actually there were two thread-safety bugs in the initial example code,
but one wouldn't usually be considered as such.

The important problem is the access to the static field. Two objects
could be created at the same time. That could lead to the second
thread's constructor run loading a value between the first's load and store.

The second problem is that Java does not guarantee anything remotely
like Sequential Consistency. You may create an object and then store a
reference to it. But there is not a guarantee that another thread will
see it in the same order. Prior to 1.4 you could ensure correct
behaviour with client code that recklessly uses objects of your class
between threads without correct synchronisation. However you would
require a synchronized block in both the constructor (very rare) and the
hashCode method. From 1.5 you can just define the field final (and make
sure not to leak this from the constructor).

Sun's implementation of Object.hashCode appears to assign the identity
hashcode lazily. Presumably to keep the allocation code as short as
possible.

Tom Hawtin

That should be fast enough for some applications ;-)

And perhaps the AtomicInteger stuff can benefit by not having to force a full
resynchronisation of local/remote memory.

What I need is a loosely coupled multiprocessor box to test this on.  Sadly, I
have neither the cash nor the space...

   -- chris

The obj reference is used in the println expression.

From a pedantic point of view, it could be removed, all except for a
copy of the hash code. One way to guarantee that objects are alive (from
1.5) is to later assign them to a volatile reference. Handy for
finalisers. Here is a corrected version of the program:

class HashClash {
    private static volatile Object dummy;
    public static void main(String[] args) {
         final Object obj = new Object();
         final int target = obj.hashCode();
         Object clash;
         long ct = 0;
         do {
             clash = new Object();
             ++ct;
         } while (clash.hashCode() != target && ct<10L*1000*1000*1000L);
         if (clash.hashCode() == target) {
             System.out.println(ct+": "+obj+" - "+clash);
         } else {
             System.out.println("No clashes found");
         }
         dummy = obj;
         dummy = clash;
    }
}

Which gives:

62028120: java.lang.Object@9cab16 - java.lang.Object@9cab16

Tom Hawtin