Volatile vs static variable in a multithreaded environment

Question

I'm currently learning multithreading and I've found something interesting that I can't explain. To the best of my knowledge if two Threads are accessing a static variable they can make their own copies into their cache. An update made by Thread1 to the static variable in its local cache wont reflect in the static variable for Thread2 cache.

For this reason my isFound static variable in Cracker.java should be static and volatile, but it doesnt matter, because all Threads immediately stop when this exit condition is set to true. Can someone explain this to me?

HashDecryptor.java

 public class HashDecryptor {    

        private List<Thread> threads = new ArrayList<>();
        // some other fields

        public HashDecryptor() {            
            createThreads();
        }

        private void createThreads() {
            long max = (long) (Math.pow(26, numberOfChars));
            int n = numberOfThreads;
            for (int i = 0; i < n; ++i) {
                if (i == 0) {
                    threads.add(new Thread(new Cracker(hashToDecrypt, (max * i / n), (max * (i + 1) / n))));
                } else {
                    threads.add(new Thread(new Cracker(hashToDecrypt, (max * i / n) + 1, (max * (i + 1) / n))));
                }
            }
        }

        public void startDecryting() {
            for (Thread t : threads) {
                t.start();
            }
        }

    }

Cracker.java

public class Cracker implements Runnable {

    // Some other fields

    private static boolean isFound;

    public Cracker(String hashToDecrypt, long start, long end) {
        this.hashToDecrypt = hashToDecrypt;
        this.start = start;
        this.end = end;
    }

    @Override
    public void run() {
        decrypt();
    }

    public void decrypt() {
        LocalTime startTime = LocalTime.now();
        long counter = start;
        while (!isFound && counter <= end) {
            if (match(counter)) {
                isFound = true;
                printData(generatePassword(counter), startTime);
            }
            counter++;
        }
    }   

}

Answer 1

For this reason my isFound static variable in Cracker.java should be static and volatile, but it doesn't matter, because all Threads immediately stop when this exit condition is set to true. Can someone explain this to me?

There are a number of ways that you can get incidental synchronization that might account for this. First of all, your application may be contending for CPU resources with other applications running on the hardware and the application may get swapped out. Maybe you have more threads than you have CPUs. Both of these may cause flushing of dirty memory to core memory when the threads get swapped out.

Another likely scenario is that your threads are crossing other memory barriers such as calling other synchronized methods or accessing other volatile fields. For example, I wonder about this statement because some of the input/output streams have synchronized classes.

printData(generatePassword(counter), startTime);

You might try to remove the printing of the data to see if your application behavior changes.

I tell you it works fine, and I did verify it with sysouts. That's the strange thing about this, and that's why I asked this question :)

Perfect example. System.out is a PrintStream which is a synchronized class so calling println() there will cause your thread to cross both a read and write memory barrier that will update your static field. It's important to note that any memory barrier affects all of the cached memory. Crossing any read memory barriers forces all cached memory to be updated from central memory. Crossing any write memory barriers forces all local dirty memory to be written to central.

The problem is when you remove the System.out methods or when you application stops calling the synchronized class and then that static variable is not properly updated. So you can't rely on it but it does happen.

Answer 2

Static variables :Are used in the context of Object where update made by one object would reflect in all the other objects of the same class but not in the context of Thread where update of one thread to the static variable will reflect the changes immediately to all the threads (in their local cache). If two Threads(suppose t1 and t2) are accessing the same object and updating a variable which is declared as static then it means t1 and t2 can make their own local copy of the same object(including static variables) in their respective cache, so update made by t1 to the static variable in its local cache wont reflect in the static variable for t2 cache .

Volatile variable: If two Threads(suppose t1 and t2) are accessing the same object and updating a variable which is declared as volatile then it means t1 and t2 can make their own local cache of the Object except the variable which is declared as a volatile . So the volatile variable will have only one main copy which will be updated by different threads and update made by one thread to the volatile variable will immediately reflect to the other Thread.