The only guide you’ll need on concurrency & multithreading for senior engineers. Pressure test your skills with real-world practice problems from top companies.

Concurrency in Java is one of the most complex and advanced topics brought up during senior engineering interviews. Knowledge of concurrency and multithreading can put interviewees at a considerable advantage. This course lays the foundations of advanced concurrency and multithreading and explains concepts such as Monitors and Deferred Callbacks in depth. It also builds simple and complete solutions to popular concurrency problems that can be asked about in interviews like the Reader-Writer Problem and the Dining Philosopher Problem. While prior knowledge of concurrency is not required to follow through with this course, familiarity with the very basics of concurrency would be helpful.

Java Multithreading for Senior Engineering Interviews


# Explanation
<p>The volatile concept is specific to Java. Its easier to understand volatile, if you understand the problem it solves.</p>

<p>If you have a variable say a counter that is being worked on by a thread, it is possible the thread keeps a copy of the counter variable in the CPU cache and manipulates it rather than writing to the main memory. The JVM will decide when to update the main memory with the value of the counter, even though other threads may read the value of the counter from the main memory and may end up reading a stale value.</p>

<p>If a variable is declared volatile then whenever a thread writes or reads to the volatile variable, the read and write always happen in the main memory. As a further guarantee, all the variables that are visible to the writing thread also get written-out to the main memory alongside the volatile variable. Similarly, all the variables visible to the reading thread alongside the volatile variable will have the latest values visible to the reading thread.</p>

# Example
Consider the program below:

```java
public class VolatileExample {

    boolean flag = false;

    void threadA() {

        while (!flag) {

            // ... Do something useful
        }

    }

    void threadB() {
        flag = true;
    }
}
```

In the above program, we would expect that `threadA` would exit the `while` loop once `threadB` sets the variable `flag` to true but `threadA` may unfortunately find itself spinning forever if it has cached the variable `flag`'s value. 
In this scenario, marking `flag` as `volatile` will fix the problem. Note that `volatile` presents a consistent view of the memory to all the threads. However, remember **that `volatile` doesn't imply or mean thread-safety**. Consider the program below where we declare the variable `count` `volatile` and several threads increment the variable a 1000 times each. If you run the program several times you'll see `count` summing up to values other than the expected 10,000. 

The Basics

Multithreading in Java

Java's Memory Model

Interview Practice Problems

Bonus Questions

Beyond the Interview

Java Concurrency Reference

Revision & Quizzes

Volatile

Explanation