The core of mastering Java concurrency is to understand thread interaction, shared state risks and coordination mechanisms, rather than memorizing the API only. 1. Understand the difference between Thread and Runnable, prioritize the implementation of Runnable or Callable, and use ExecutorService to manage threads to improve resource utilization and scalability; 2. Prevent race conditions for shared variables under multi-threads through synchronized keywords or AtomicInteger, and use CAS to achieve efficient lock-free operation; 3. Use thread-safe collections such as ConcurrentHashMap, CopyOnWriteArrayList and BlockingQueue to avoid data corruption, especially BlockingQueue can simplify blocking coordination of producer-consumer models; 4. Avoid deadlocks to obtain locks in a fixed order, or use ReentrantLock to cooperate with the timeout mechanism to reduce unlimited waiting risks; 5. volatile ensures variable visibility but does not guarantee atomicity. It is suitable for flag bits. Compound operations still require Atomic class or synchronization control; 6. Priority is given to the use of advanced concurrency tools such as CountDownLatch, CyclicBarrier, Semaphore and CompletableFuture to improve code readability and reliability. Finally, we should minimize shared variable state, adopt immutable design, thread-local storage or responsive streams, and build predictable and maintainable highly concurrent programs based on the JDK concurrency tool library.

Mastering Java concurrency and multithreading isn't about memorizing APIs—it's about understanding how threads interact, how shared state can break your program, and how to coordinate safely and efficiently. If you're building high-performance Java applications, concurrency is unavoidable. Here's what actually matters.

1. Understand the Core Concepts: Thread vs Runnable

Start by knowing the difference between Thread and Runnable . While you can extend Thread , the better practice is implementing Runnable (or Callable for return values). This keeps your task logic separate from thread management.

 Runnable task = () -> System.out.println("Running in: " Thread.currentThread().getName());
Thread t = new Thread(task);
t.start(); // Don't call run() directly

Key insight: Calling run() directly runs the code on the current thread. Always use start() to spawn a new thread.

Also, prefer ExecutorService over raw threads:

 ExecutorService executor = Executors.newFixedThreadPool(4);
executor.submit(task);
// Remember to shutdown
executor.shutdown();

This gives you thread reuse, better resource management, and scalability.

2. Guard Against Race Conditions with Proper Synchronization

When multiple threads access shared mutable data, chaos ensures. Consider this classic problem:

 int counter = 0;
// Multiple threads doing:
counter ; // Not atomic!

The increment is three operations: read, increment, write. Without synchronization, threads can overwrite each other.

Solutions:

• Use synchronized keyword:

   public synchronized void increment() {
      counter ;
  }

• Use java.util.concurrent.atomic classes:

   AtomicInteger counter = new AtomicInteger(0);
  counter.incrementAndGet(); // Lock-free, thread-safe

Atomic classes use CPU-level CAS (Compare-And-Swap) instructions—fast and efficient for simple operations.

3. Choose the Right Thread-Safe Collections

Using ArrayList or HashMap across threads? You're asking for ConcurrentModificationException or silent data corruption.

Instead:

• ConcurrentHashMap — high-performance concurrent map
• CopyOnWriteArrayList — good for read-heavy, infrequent writes
• BlockingQueue implementations ( LinkedBlockingQueue , ArrayBlockingQueue ) — great for producer-consumer patterns

Example: Producer-consumer with BlockingQueue

 BlockingQueue<String> queue = new LinkedBlockingQueue<>(10);

// Producer
executor.submit(() -> {
    for (int i = 0; i < 100; i ) {
        queue.put("Item " i); // Blocks if full
    }
});

// Consumer
executor.submit(() -> {
    while (true) {
        try {
            String item = queue.take(); // Blocks if empty
            System.out.println("Consumed: " item);
        } catch (InterruptedException e) { break; }
    }
});

Blocking behavior simplifies coordination—no need to poll or spin.

4. Avoid Deadlock with Careful Lock Ordering

Deadlock happens when threads wait for locks the others hold, forever. Classic example: two threads trying to acquire two locks in opposite orders.

Prevention tip: Always acquire locks in a consistent global order.

Better yet: avoid synchronized blocks with multiple locks . Use higher-level concurrency tools instead.

Or use java.util.concurrent.locks.ReentrantLock with timeouts:

 ReentrantLock lock1 = new ReentrantLock();
ReentrantLock lock2 = new ReentrantLock();

boolean acquired1 = lock1.tryLock(1, TimeUnit.SECONDS);
boolean acquired2 = lock2.tryLock(1, TimeUnit.SECONDS);

if (acquired1 &&acquired2) {
    try {
        // do work
    } finally {
        if (acquired2) lock2.unlock();
        if (acquired1) lock1.unlock();
    }
}

This avoids indeed blocking.

5. Use volatile for Visibility, Not Atomicity

Declaring a variable volatile ensures that changes are immediately visible to other threads—but it doesn't make compound operations atomic.

 volatile boolean running = true;

// Thread 1
while (running) {
    // do work
}

// Thread 2
running = false; // Other thread will see this change

This is perfect for flags. But volatile int counter won't fix counter .

For both visibility and atomicity, use AtomicInteger or synchronization.

6. Prefer High-Level Concurrency Utilities

Java's java.util.concurrent package is full of battle-tested tools:

• CountDownLatch : Wait for a set of operations to complete
• CyclicBarrier : Let threads wait for each other at a barrier point
• Semaphore : Control access to a resource pool
• CompletableFuture : Compose asynchronous operations

Example: Wait for 3 services to start

 CountDownLatch latch = new CountDownLatch(3);

for (int i = 0; i < 3; i ) {
    executor.submit(() -> {
        // simulate service start
        Thread.sleep(1000);
        latch.countDown();
    });
}

latch.await(); // Blocks until all 3 call countDown()
System.out.println("All services started.");

These tools are clearer and safer than manual wait() / notify() .

Final Thoughts

Mastering concurrency isn't about writing the most clever multithreaded code—it's about writing the most predictable and maintainable one. Focus on:

• Minimizing shared mutable state
• Using thread-safe classes from java.util.concurrent
• Preferring immutability and functional-style designs
• Testing under load (race conditions often only appear under stress)

And remember: if you can avoid shared state, do it . Sometimes, the best concurrent design is one that avoids sharing altogether—think message passing, thread-local storage, or reactive streams.

Basically, keep it simple, test thoroughly, and lean on the JDK's concurrency toolkit. It's there for a reason.

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