Ok, that is not contention.

I don't know any tool that is capable of this.  If you think a bit about
the issue you will recognize that it's at minimum very hard if not
impossible.  For example, objects might be drawn from a pool in a thread
safe manner that ensures only one thread at a time has access to an
instance.  Now accesses to these instances do not need to be synchronized
because they are confined to a single thread even though they are accessed
by multiple threads through their lifetime.  How should a tool go about
this and detect that it's an access that does not need a warning?

Even if you access a single instance concurrently by multiple threads it's
not very likely that two threads access an instance at exactly the same
time; if they don't you would have to watch for concurrent accesses in a
certain interval.  But how large an interval should the tool watch?

And after all, there might be accesses to instance data which after
construction of an instance never changes.  So unsynchronized access to
these methods is completely ok.

The problem with all this is, that it depends on the application's
semantic whether an unsynchronized access is ok or not.  Since software
tools don't have access to semantics, it'll be very hard to come up with a
tool that gives reasonable warnings (i.e. with a good heuristic that
doesn't yield too many false positives).

Kind regards

   robert