• Review:
  • Shared mutable state variables can be protected using synchronized methods/blocks and other coordination mechanisms
• An Observation:
  • Such methods are less efficient than non-blocking algorithms that use low-level atomic machine instructions

• Pessimistic Methods:
  • Assume the worst and don't proceeed until it can be guaranteed that other threads won't cause problems
• Optimistic Methods:
  • Perform an update hoping that it can be completed and then check for interference

• Support on CPUs:
  • Many CPUs now support such instructions (e.g., a compare-and-swap instruction; load-linked and store-conditional instructions)
• Support in the Java Virtual Machine:
  • The JVM uses these instructions when available and simulates them efficiently when not

• Purpose:
  • Support atomic conditional read-modify-write operations
• The Classes:
  • AtomicBoolean
  • AtomicInteger
  • AtomicLong
• The Important Methods:
  • addAndGet(), decrementAndGet(), incrementAndGet()
  • getAndAdd(), getAndDecrement(), getAndIncrement()
  • compareAndSet(), weakCompareAndSet()
  • get(), lazySet(), set()

• Recall:
  • We created a NonatomicInteger class to demonstrate the problems that can arise when using shared mutable state
  • We created a SynchronizedInteger class to demonstrate how these problems could be overcome with synchronization
• Now:
  • We're going to use an AtomicInteger instead

The Counter Class

javaexamples/atomic/Counter.java

import java.util.concurrent.atomic.*;

/**
 * An implementation of Runnable that increases a mutable integer.
 *
 * This version uses the AtomicInteger class to show how it corrects
 * the problems of using shared mutable state.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 2.0
 */
public class Counter implements Runnable
{
    private int                iterations;
    private AtomicInteger      mutable;
    
    /**
     * Explicit Value Constructor.
     *
     * @param mutable    The AtomicInteger to use
     * @param iterations The number of times to increment the AtomicInteger
     */
    public Counter(AtomicInteger mutable, int iterations)
    {
        this.mutable    = mutable;        
        this.iterations = iterations;        
    }
    
    /**
     * The code to run in the thread of execution.
     */
    public void run()
    {
        for (int i=0; i<iterations; i++)
        {
            mutable.incrementAndGet();
        }
        System.out.printf("Value: %d\n", mutable.get());
    }
}
        

The Application

javaexamples/atomic/CounterDriver.java

import java.util.concurrent.atomic.*;

/**
 * An application that illustrates how the AtomicInteger class can prevent
 * some of the problems that can arise
 * when using shared mutable state.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 2.0
 */
public class CounterDriver
{
    private static final int ITERATIONS = 1000000;    
    private static final int THREADS    = 5;    

    /**
     * The entry point of the application.
     *
     * @param args  The command line arguments
     */
    public static void main(String[] args)
    {
        AtomicInteger       mutable;

        mutable = new AtomicInteger(0);
        
        for (int i=0; i<THREADS; i++)
        {
            Thread thread = new Thread(new Counter(mutable, ITERATIONS));
            thread.start();
        }
    }
}
        

• Purpose:
  • Used when multiple threads update a common sum
• Classes:
  • DoubleAdder
  • LongAdder
• Comparison to AtomicLong:
  • Under high contention, expected throughput is significantly higher, at the expense of higher space consumption

• The Classes:
  • AtomicIntegerArray
  • AtomicLongArray
• The Methods:
  • Similar to those in AtomicInteger and AtomicLong but they have a parameter for the element index

• Purpose:
  • An object reference that can be updated atomically
• The Most Common Use:
  • Concurrent collections
• Examples:
  • A nonblocking stack (e.g., using Treiber's algorithm)
  • ConcurrentLinkedQueue
  • ConcurrentLinkedDeque
  • ConcurrentSkipListMap

• Existing Classes:
  • There aren't any other than the DoubleAdder (for a variety of reasons)
• A Workaround:
  • static long Double.doubleToLongBits(double value)
  • static double Double.longBitsToDouble(long bits)