Question

Will the following code cause same problems, if variable ‘commonSet’ of this method was instead a class level field. If it was a class level field, I’ll have to wrap adding to set operation within a synchronized block as HashSet is not thread safe. Should I do the same in following code, since multiple threads are adding on to the set or even the current thread may go on to mutate the set.

public void threadCreatorFunction(final String[] args) {
    final Set<String> commonSet = new HashSet<String>();

    final Runnable runnable = new Runnable() {
        @Override
        public void run() {
            while (true) {
                commonSet.add(newValue());
            }
        }
    };

    new Thread(runnable, "T_A").start();
    new Thread(runnable, "T_B").start();
}

The reference to ‘commonSet’ is ‘locked’ by using final. But multiple threads operating on it can still corrupt the values in the set(it may contain duplicates?). Secondly, confusion is since ‘commonSet’ ia a method level variable – it’s same reference will be on the stack memory of the calling method (threadCreatorFunction) and stack memory of run methods – is this correct?

There are quite a few questions related to this:

• Why do variables passed to runnable need to be final?
• Why are only final variables accessible in anonymous class?

But, I cannot see them stressing on thread safe part of such sharing/passing of mutables.

Answer 1

No, this is absolutely not thread-safe. Just because you’ve got it in a final variable, that means that both threads will see the same reference, which is fine – but it doesn’t make the object any more thread-safe.

Either you need to synchronize access, or use ConcurrentSkipListSet.