The AtomicInteger Java class (in the java.util.concurrent.atomic package) is a container for an integer value. One of its methods is def compareAndSet(expect: Int, update: Int): Boolean.

This method compares the object’s current value to expect. If the values are equal, then it atomically replaces the object’s value with update and returns true. Otherwise, it leaves the object’s value unchanged, and returns false. This class also provides get() : Int which returns the object’s actual value. Consider the FIFO queue implementation given by the class IQueue. It stores its items in an array items. It has two AtomicInteger fields: tail is the index of the next slot from which to remove an item, and head is the index of the next slot in which to place an item. Give an example showing that this implementation is not linearizable.

1 class IQueue

2 AtomicInteger head = new AtomicInteger(0);

3 AtomicInteger tail = new AtomicInteger(0);

4 T[] items = (T[]) new Object[Integer.MAX_VALUE];

5 public void enq(T x) {

6 int slot;

7 do {

8 slot = tail.get();

9 } while (! tail.compareAndSet(slot, slot+1));

10 items[slot] = x;

11 }

12 public T deq() throws EmptyException {

13 T value;

14 int slot;

15 do {

16 slot = head.get();

17 value = items[slot];

18 if (value == null)

19 throw new EmptyException();

20 } while (! head.compareAndSet(slot, slot+1));

21 return value;

22 }

23 }