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

If you are interviewing, consider buying our number#1 course for <a href="https://www.educative.io/courses/java-multithreading-for-senior-engineering-interviews?affiliate_id=5457430901161984" target="_blank">Java Multithreading Interviews</a>.

# Overview
The `AtomicMarkedReference` class is similar to the `AtomicStampedReference` class in that it holds a reference to an object but instead of an integer stamp it takes in a boolean value, called the mark. Both these fields can be updated atomically either together or individually. One could argue that `AtomicStampedReference` class would behave similarly to `AtomicMarkableReference` class if it accepted only two possible values for the integer stamp argument.

The code widget below demonstrates some of the basic operations when working with the `AtomicMarkableReference` class.

import java.util.concurrent.atomic.AtomicMarkableReference;

class Demonstration {

 public static void main( String args[] ) {

 Long myLong = new Long(5);
 Long anotherLong = new Long(7);
 AtomicMarkableReference<Long> atomicMarkableReference = new AtomicMarkableReference<>(myLong, false);

 // attempt to change the long value with the wrong expected mark
 boolean wasSuccess = atomicMarkableReference.compareAndSet(myLong, anotherLong, true, true);
 System.out.println("compare and set succeeded " + wasSuccess + " current value " + atomicMarkableReference.getReference());

 // attempt to change the long value with the right expected mark
 wasSuccess = atomicMarkableReference.compareAndSet(myLong, anotherLong, false, true);
 System.out.println("compare and set succeeded " + wasSuccess + " current value " + atomicMarkableReference.getReference());
 }
}

# Example
`AtomicMarkableReference` can be put to good use when designing lock-free lists, such as a set representation backed by a linked-list. In this lesson, we’ll not go through the implementation of a lock-free list but discuss parts of the implementation where the class `AtomicMarkableReference` is applicable.

Consider the `SimpleNode` class which represents a node in the linked list. The class uses an `AtomicReference` for the `next` node in the list, so that it can be updated atomically. The goal is to keep the list lock-free and update the `next` of the node correctly when a node is deleted. We’ll create a set-up that creates a race condition and causes the list to reach an inconsistent state.

Say we have three nodes linked as follows:

NodeA → NodeB → NodeC → null

Say we have two threads `thread1` and `thread2`, each one trying to delete NodeA and NodeB respectively. The following sequence of events can cause the NodeC to not be deleted:
1. `thread1` stores the `next` of NodeA, which points to NodeB and the `next` of NodeB which points to NodeC in the variables `expected` and `newNext` respectively. These variables serve as the expected and the new value for the `compareAndSet()` method of the `AtomicReference`.

2. At this point `thread1` is suspended. We simulate that by sleeping the thread.

3. `thread2` starts and attempts to delete NodeC. `thread1`  computes the expected value for the `next` of NodeB, which is NodeC itself and the new next value which should be null, since NodeC is the last node of the list.

4. `thread2` continues and successfully deletes NodeC.

5. `thread1` wakes up and proceeds to execute the `compareAndSet()` call, which should succeed because NodeA still points to NodeB (the expected value) but the new `next` points to NodeC which has been deleted.

6. The program ends in a state where NodeC is not deleted and remains part of the list.

The above scenario is depicted in the code widget below:
 

Learn to use the AtomicMarkableReference class for designing lock-free data structure such as linked-lists.

The Basics

Multithreading in Java

Java's Memory Model

Interview Practice Problems

Bonus Questions

Beyond the Interview

Java Concurrency Reference

Revision & Quizzes

AtomicMarkableReference

Overview