ThreadPoolExecutor should be used to manually configure thread pools, select bounded queues, appropriate rejection policies, and name threads to avoid OOM and facilitate troubleshooting; 2. Use CompletableFuture to realize chain orchestration and combination of asynchronous tasks, improve asynchronous processing capabilities through thenCombine, allOf, and other methods, and specify a custom thread pool to avoid using public pools; 3. Use Phaser to replace CountDownLatch and CyclicBarrier, because it supports dynamic registration, multi-stage synchronization and participant logout, which is suitable for complex synchronization scenarios; 4. Use ReentrantReadWriteLock in read and write scenarios to improve concurrency performance, pay attention to the order of obtaining and releasing read and write locks; 5. It is recommended to use StampedLock for extreme read and write scenarios The optimistic reading mode of the system improves performance through tryOptimisticRead and validate, but it should be noted that it is not reentered and cannot be mixed with synchronized; 6. Use ThreadLocal to implement thread-local storage, suitable for isolation and contextual delivery of non-threadsafe objects. Be sure to call remove() after use to prevent memory leakage; 7. Use Disruptor to replace BlockingQueue in high-throughput scenarios such as financial transactions, and implement low-latency, high-throughput event processing based on ring buffers and lock-free designs. Events, factories and processors need to be defined and appropriate policies are configured. These modes need to be selected and used according to the actual scenario to effectively improve system performance and stability.

Java's concurrency and multi-threaded programming are the key to building high-performance and scalable applications. As modern applications have increasingly demanded responsiveness, throughput, and resource utilization, mastering advanced concurrency patterns has become particularly important. This article will explore in-depth several advanced Java concurrency and multithreading patterns that are very useful in actual development, helping you write more robust and efficient concurrent code.

1. Reasonable use and customization of thread pools (ThreadPoolExecutor advanced configuration)

Although Executors tool class provides convenient ways to create thread pools, using newFixedThreadPool or newCachedThreadPool directly in production environments can easily cause problems (such as OOM). It is also recommended to use ThreadPoolExecutor to configure manually.

 ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, // The number of core threads is 10, // The maximum number of threads is 60L, // Idle thread survival time TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100), // Task Queue new CustomThreadFactory(), // Thread Factory (nameable threads)
    new ThreadPoolExecutor.CallerRunsPolicy() // Denied policy);

Key points:

• Queue selection : ArrayBlockingQueue (bounded) is safer than LinkedBlockingQueue (default unbounded).
• Rejection policy :
  • AbortPolicy : throw exception (default)
  • CallerRunsPolicy : executed by the thread that submits the task (to prevent avalanches)
• Thread naming : Set meaningful thread names through ThreadFactory to facilitate troubleshooting.

2. CompleteFuture implements asynchronous orchestration

CompletableFuture is a powerful asynchronous programming tool introduced by Java 8, supporting chain calls and combining multiple asynchronous tasks.

 CompleteFuture<String> future1 = CompleteFuture.supplyAsync(() -> {
    // Simulation time-consuming operation sleep(1000);
    return "Result1";
});

CompleteFuture<String> future2 = CompleteFuture.supplyAsync(() -> {
    sleep(800);
    return "Result2";
});

// Combined two tasks CompletableFuture<String> combined = future1.thenCombine(future2, (r1, r2) -> r1 "-" r2);

combined.thenAccept(System.out::println).join();

Common methods:

• thenApply() : Convert the result
• thenCompose() : Serial asynchronous task (flatMap semantics)
• allOf() / anyOf() : Multiple tasks are synchronized or any completed
• Custom thread pool: Avoid using ForkJoinPool.commonPool()

 CompletableFuture.supplyAsync(() -> compute(), executor);

3. Use Phaser to replace CountDownLatch and CyclicBarrier

Phaser is a more flexible synchronization tool that supports dynamic registration of participants, reusable, and phased.

 Phaser phaser = new Phaser();
phaser.register(); // The main thread also participates for (int i = 0; i < 3; i ) {
    phaser.register();
    new Thread(() -> {
        System.out.println(Thread.currentThread().getName() "Start the first stage");
        phaser.arriveAndAwaitAdvance(); // Wait for everyone to arrive at System.out.println(Thread.currentThread().getName() "Start the second stage");
        phaser.arriveAndAwaitAdvance();

        phaser.arriveAndDeregister(); // Complete and log out}).start();
}

phaser.arriveAndDeregister(); // The main thread exits

Advantages:

• Dynamic addition and decrease participation threads
• Supports multi-stage synchronization
• You can listen for the beginning and end of each phase (via onAdvance() )

4. Use ReadWriteLock to optimize read more and write less scenarios

In scenarios with high concurrent reading and low frequency writing, ReentrantReadWriteLock can significantly improve performance.

 public class Cache {
    private final Map<String, String> map = new HashMap<>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();

    public String get(String key) {
        readLock.lock();
        try {
            return map.get(key);
        } finally {
            readLock.unlock();
        }
    }

    public void put(String key, String value) {
        writeLock.lock();
        try {
            map.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }
}

Notice:

• Read locks are not mutually exclusive, write locks are exclusive
• Cannot re-enter the write lock to the read lock (it will be deadlocked), it needs to be explicitly released before obtaining
• JDK 17 Recommended to consider StampedLock (Optimistic Reading)

5. StampedLock: High-performance read and write lock (optimistic lock mode)

StampedLock provides three modes: write lock, pessimistic reading lock, and optimistic reading lock , which is suitable for scenarios where more reads, less writes.

 public class Point {
    private double x, y;
    private final StampedLock sl = new StampedLock();

    public double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead(); // Optimistic read double currentX = x, currentY = y;

        if (!sl.validate(stamp)) { // Check whether there is a write operation during the checking period stamp = sl.readLock(); // Upgrade to pessimistic reading try {
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX currentY * currentY);
    }
}

advantage:

• Optimistic reading and writing without blocking, extremely high performance
• High priority for writing operations

shortcoming:

• Do not reenter
• Can't be mixed with synchronized
• The lock status is managed through long stamp , and you need to be careful when using it.

6. Concurrent design pattern: Thread-Local Storage and object pool

ThreadLocal usage scenarios

 private static final ThreadLocal<SimpleDateFormat> formatter = ThreadLocal.withInitial(
    () -> new SimpleDateFormat("yyyy-MM-dd")
);

public String formatDate(Date date) {
    return formatter.get().format(date);
}

Applicable to:

• Isolation of non-thread-safe tool classes (such as SimpleDateFormat )
• Context delivery (such as user identity, request ID)

Note memory leaks:

• ThreadLocal 's Entry is WeakReference , but the value may still leak
• It is recommended to call remove() after using it

 formatter.remove();

7. Use Disruptor to implement high-performance event queues (replace BlockingQueue)

In ultra-high throughput scenarios (such as financial transactions, log systems), Disruptor performs better than BlockingQueue , based on ring buffers and lock-free design.

Basic usage steps:

• Define event classes
• Create an event factory
• Define event handler (EventHandler)
• Build a Disruptor instance and start

 Disruptor<LongEvent> disruptor = new Disruptor<>(
    LongEvent::new,
    bufferSize,
    Executors.defaultThreadFactory(),
    ProducerType.MULTI,
    new BlockingWaitStrategy()
);

Advantages:

• Lockless producer/consumer
• High throughput, low latency
• Preallocate objects to reduce GC

Basically that's it. These advanced concurrency modes can significantly improve the stability and performance of the system in actual projects. The key is not to pile up techniques, but to choose the right tools based on the scene:

• Generally, asynchronous use of CompletableFuture
• StampedLock for high concurrent reading
• Phaser for multi-stage synchronization
• High throughput queues consider Disruptor

Not complicated, but it is easy to ignore details.

The above is the detailed content of Advanced Java Concurrency and Multithreading Patterns. For more information, please follow other related articles on the PHP Chinese website!