Java AtomicLong

last modified May 25, 2025

In this article, we work with Java's AtomicLong.

AtomicLong provides a long variable that can be read and written atomically. It ensures that operations on the variable are thread-safe, preventing issues like lost updates in concurrent environments.

AtomicLong is a class within the java.util.concurrent.atomic package that provides an atomic and thread-safe way to represent and manipulate a long primitive data type.

AtomicLong is a synchronization primitive. It provides atomic operations for long values, ensuring thread-safe access and modification. Unlike traditional locks, which can introduce performance overhead, AtomicLong leverages low-level atomic instructions to maintain data consistency without blocking threads. Its primary purpose is to handle concurrent updates efficiently while avoiding race conditions.

Key characteristics:

• Atomic operations: AtomicLong guarantees that read and write operations on the underlying long value are atomic. This means each operation executes as a single, indivisible unit, even if multiple threads are trying to access the value concurrently. This prevents inconsistencies and data races that can occur with regular long variables in a multithreaded environment.
• Thread-safety: By ensuring atomic operations, AtomicLong makes it safe to use the same long value across multiple threads without requiring explicit synchronization mechanisms like locks. This simplifies thread-safe programming and reduces the risk of concurrency issues.
• Common operations: The class provides various methods for atomically performing operations on the long value, such as retrieving the current value, setting a new value, incrementing or decrementing the value, and performing compare-and-swap operations.

Benefits of using AtomicLong:

• Prevents data races: Guaranteeing atomic operations avoids inconsistencies that can arise when multiple threads try to read or write the same long value simultaneously.
• Simplifies concurrent programming: Eliminates the need for complex synchronization code in scenarios where multiple threads access a long variable.
• Improved performance: Atomic operations can be more efficient than using locks, particularly for frequently accessed variables.

Use cases for AtomicLong:

• Counters: AtomicLong is ideal for representing counters that are incremented or decremented by multiple threads in a concurrent environment, such as tracking website visitors or active network connections.
• Sequence numbers: It can be used to generate unique and atomically incremented sequence numbers, useful for purposes like logging or transaction IDs.
• State flags: AtomicLong can serve as a simple flag variable that multiple threads can set or reset atomically, indicating a specific state or condition.

Counter example

In the next example, we generate 500 threads. Each thread increments a counter.

class Counter {

    private final AtomicLong counter = new AtomicLong(0);

    public void inc() {

        counter.getAndIncrement();
    }

    public long get() {

        return counter.get();
    }
}


void main() throws InterruptedException {

    final Counter counter = new Counter();

    // 500 threads
    for (int i = 0; i < 500; i++){

        var thread = new Thread(counter::inc);

        thread.start();
    }

    // sleep three seconds
    Thread.sleep(3000);

    System.out.println("Value: " + counter.get());
}

In the end, the counter should be 500.

private final AtomicLong counter = new AtomicLong(0);

The counter is an AtomicLong initiated to 0.

public void inc() {

    counter.getAndIncrement();
}

The inc method increments the counters safely.

public long get() {

    return counter.get();
}

The get method returns the current value of the counter.

Source

Java AtomicLong - language reference

In this article we have worked with AtomicLong in Java.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Java tutorials.