Does this variable need to be declared volatile?

Question

Does the out variable in the MyThread class need to be declared volatile in this code or will the "volatility" of the stdout variable in the ThreadTest class carry over?

import java.io.PrintStream;

class MyThread implements Runnable
{
    int id;
    PrintStream out; // should this be declared volatile?

    MyThread(int id, PrintStream out) {
        this.id = id;
        this.out = out;
    }

    public void run() {
        try {
            Thread.currentThread().sleep((int)(1000 * Math.random()));
            out.println("Thread " + id);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadTest
{
    static volatile PrintStream stdout = System.out;

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new MyThread(i, stdout)).start();
        }
    }
}

Answer 1

It definitely won't carry over. I'm not sure what you're trying to do, though. volatile qualifies the field in ThreadTest, not the value.

Answer 2

Does the out variable in the MyThread class need to be declared volatile in this code or will the "volatility" of the stdout variable in the ThreadTest class carry over?

The volatility does not "carry over" because you actually passing the value of the variable.

According to my reading of the JLS memory model spec, a volatile is required if you were to read out without some intervening synchronization between the thread that created the object and the thread that uses it. But a better solution would be to declare out as final. The semantics of final fields mean that no synchronization is required.

Answer 3

The volatile qualifier won't carry through, and it serves no purpose in the above code. Volatile establishes a memory barrier on reads and writes to the variable, which is never modified once initialised in the constructor. For the same reason, the volatile qualifier in ThreadTest serves no purpose either.

Just to be clear, volatile applies to the variable, not to the referenced object.