If more than one thread can access a field should it be marked as volatile?

Question

Reading a few threads (common concurrency problems, volatile keyword, memory model) I'm confused about concurrency issues in Java.

I have a lot of fields that are accessed by more than one thread. Should I go through them and mark them all as volatile?

When building a class I'm not aware of whether multiple threads will access it, so surely it is unsafe to let any field not be volatile, so by my understanding there's very few cases you wouldn't use it. Is this correct?

For me this is specific to version 1.5 JVMs and later, but don't feel limited to answering about my specific setup.

Answer 1

Well, you've read those other questions and I presume you've read the answers already, so I'll just highlight some key points:

1. are they going to change? if not, you don't need volatile
2. if yes, then is the value of a field related to another? if yes, go to point 4
3. how many threads will change it? if only 1, then volatile is all you need
4. if the answer to number 2 is "no" or more than one threads is going to write to it, then volatile alone is not enough, you'll probably need to synchronize the access

Added:
If the field reference an Object, then it will have fields of its own and all those consideration also applies to these fields.

Answer 2

If a field is accessed by multiple threads, it should be volatile or final, or accessed only with synchronized blocks. Otherwise, assigned values may not be visible to other threads.

A class has to be specifically designed for concurrent access by multiple threads. Simply marking fields volatile or final is not sufficient for thread-safety. There are consistency issues (atomicity of changes to multiple fields), concerns about inter-thread signaling (for example using wait and notify), etc.

So, it is safest to assume that an object should be visible to only a single thread unless it is documented otherwise. Making all of your objects thread-safe isn't necessary, and is costly—in terms of software speed, but more importantly, in terms of development expense.

Instead, software should be designed so that concurrent threads interact with each other as little as possible, preferably not at all. The points where they do interact need to be clearly identified so that the proper concurrency controls can be designed.