synchronized is the earliest synchronization mechanism in Java. It is simple and easy to use and has good performance after optimization, but lacks flexibility; 2. ReentrantLock provides advanced functions such as interruptibility, reentrant, and support fairness, which is suitable for scenarios that require fine control; 3. The lock-free algorithm implements non-blocking concurrency based on CAS, such as AtomicLong, LongAdder and ConcurrentLinkedQueue, which performs better in a high-competitive environment, but needs to deal with ABA problems and CPU spin overhead; ultimately, appropriate strategies should be selected based on the concurrency strength: synchronized for low-competitive competition, and ReentrantLock for control, and lock-free structure for high-concurrency scenarios, so as to achieve the evolution from basic synchronization to high-performance concurrency.

Java's multi-threaded programming has gradually evolved from the early synchronized keyword to the more flexible Lock framework, and then to the lock-free (Lock-Free) algorithm widely used in high-performance scenarios today. Mastering this evolution path will not only help to write more efficient concurrent programs, but also provide a deep understanding of the concurrency mechanisms at the modern JVM and hardware levels.

The following is an analysis from three levels: synchronized → explicit lock ( ReentrantLock ) → lock-free algorithm (Lock-Free), which takes you from basic to advanced.

1. synchronized: the most primitive but still efficient synchronization mechanism

synchronized is the earliest thread synchronization keyword provided by Java. It can be used in method or code blocks to ensure that only one thread can enter the critical area at the same time.

 public synchronized void increment() {
    count ;
}

advantage:

• Simple and easy to use, JVM automatically manages the acquisition and release of locks.
• After a lot of optimizations (biased locks, lightweight locks, lock expansion, etc.) after JDK 1.6, the performance has been greatly improved.

shortcoming:

• It is not interruptible, and the interrupt cannot be responded to when the thread is blocked.
• Cannot try to add lock (no tryLock).
• Fairness control is not supported.
• The locking particle size is relatively coarse and has poor flexibility.

Nevertheless, synchronized is still preferred in most ordinary concurrency scenarios , because its performance is already very close to explicit locking and is not prone to errors.

2. Explicit lock: more flexible control

Java 5 introduces the java.util.concurrent.locks.Lock interface, the most commonly used is ReentrantLock , which provides richer functions than synchronized .

 private final ReentrantLock lock = new ReentrantLock();

public void increment() {
    lock.lock();
    try {
        count ;
    } finally {
        lock.unlock();
    }
}

Key Advantages:

• Support interruptible lock acquisition ( lockInterruptibly() )
• Supports trying to add locks ( tryLock() ) to avoid infinite waiting
• Support fair locks ( true is passed in during construction) to reduce thread hunger
• Fine-grained conditional control ( Condition )

Recommended usage:

• Use ReentrantLock when you need timeout attempts, interrupt responses, or fairness.
• It must be used in conjunction with try-finally , otherwise deadlocks are prone to occur.

But note: explicit locks are still "blocking" . If the thread cannot get the lock, it will be suspended, and context switching will bring overhead.

3. Lock-Free algorithm: non-blocking concurrency based on CAS

True high-performance concurrency, especially in high-competitive scenarios (such as high-frequency trading, high-concurrency counters, lock-free queues), needs to get rid of the concept of "lock" and turn to the Lock-Free or Wait-Free algorithm.

Its core is CAS (Compare-And-Swap) operation, provided by Unsafe class, encapsulated in Java through java.util.concurrent.atomic package.

CAS Principle:

 // Pseudocode: update to update only if the current value is equal to expect
boolean compareAndSet(int expect, int update);

Example: Atomic integer counter

 private final AtomicLong counter = new AtomicLong(0);

public void increment() {
    counter.incrementAndGet(); // Internal based CAS loop}

ABA issues with CAS

CAS only compares whether the values are equal, and does not care whether the middle has been modified. For example:

• Thread 1 reads the value A
• Thread 2 Turn A → B → A
• Thread 1 executes CAS(A, new_value), successfully, but the intermediate state has been tampered with

Solution : Use AtomicStampedReference to introduce a version number (timestamp) to distinguish real changes.

 AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(100, 0);

int stamp = ref.getStamp();
Integer value = ref.getReference();
if (ref.compareAndSet(value, newValue, stamp, stamp 1)) {
    // Updated successfully}

4. Advanced Lock-Free Data Structure

JDK provides some high-performance containers based on lock-free algorithms:

1. ConcurrentLinkedQueue

• Lockless thread-safe queue
• Implement offer() and poll() based on CAS
• Suitable for high concurrency producers-consumer scenarios

2. AtomicIntegerFieldUpdater / AtomicReferenceFieldUpdater

• Can perform atomic operations on the volatile field of a normal object
• Avoid creating AtomicInteger objects for each field, saving memory

 public class Task {
    volatile int state;
    static final AtomicIntegerFieldUpdater<Task> updater =
        AtomicIntegerFieldUpdater.newUpdater(Task.class, "state");

    public boolean setStateIf(int expected, int newValue) {
        return updater.compareAndSet(this, expected, newValue);
    }
}

3. LongAdder vs AtomicLong

• In high concurrency accumulation scenarios, LongAdder performance is far superior AtomicLong
• Principle: segmented accumulation (segment of segmented locking idea of ConcurrentHashMap), final summary

 private final LongAdder adder = new LongAdder();

public void increment() {
    adder.increment(); // There are fewer conflicts under high concurrency}

public long getTotal() {
    return adder.sum(); // Summarize the values of all segments}

5. Implement a simple Lock-Free stack (lockless stack)

 public class LockFreeStack<T> {
    private final AtomicReference<Node<T>> top = new AtomicReference<>();

    private static class Node<T> {
        final T value;
        final Node<T> next;

        Node(T value, Node<T> next) {
            this.value = value;
            this.next = next;
        }
    }

    public void push(T value) {
        Node<T> newHead = new Node<>(value, null);
        Node<T> currentHead;
        do {
            currentHead = top.get();
            newHead = new Node<>(value, currentHead);
        } while (!top.compareAndSet(currentHead, newHead));
    }

    public T pop() {
        Node<T> currentHead;
        Node<T> newHead;
        do {
            currentHead = top.get();
            if (currentHead == null) return null;
            newHead = currentHead.next;
        } while (!top.compareAndSet(currentHead, newHead));
        return currentHead.value;
    }
}

This stack uses AtomicReference and CAS to implement push/pop, and there is no lock in the whole process, but please note:

• Loop retry (spin) may consume CPU
• Not suitable for long-term operation

Summary: The evolution logic from synchronized to Lock-Free

Recommendations for use

• synchronized is preferred for normal scenarios, which is fast and safe enough.
• Use ReentrantLock when timeout, interrupt, and fairness are required.
• High concurrency counting and status update use AtomicXXX or LongAdder .
• When building high-performance queues, stacks, etc., consider ConcurrentLinkedQueue or handwritten CAS structure.
• Note: No lock ≠ no cost. CAS failed retry may cause CPU waste and need to be evaluated in combination with scenarios.

Basically that's it. By mastering these levels, you can choose the most appropriate synchronization strategy at different concurrency intensity, from "knowing to use locks" to "knowing concurrency".

The above is the detailed content of Advanced Java Multithreading: from synchronized to Lock-Free Algorithms. For more information, please follow other related articles on the PHP Chinese website!