Race conditions occur when multiple threads access shared data, leading to inconsistencies; fix with synchronized, AtomicInteger, or ReentrantLock. 2. Deadlock arises when threads wait indefinitely for each other’s locks; prevent by consistent lock ordering, using tryLock with timeout, and monitoring with jstack. 3. Visibility issues happen due to CPU caching or reordering; resolve with volatile keyword, though compound operations still need synchronization. 4. Liveness problems include starvation, where threads are denied resources, mitigated by fair locks, and livelock, where threads make no progress, resolved with random backoffs. 5. Misusing wait()/notify() causes missed signals or exceptions; always use wait() in a while loop within a synchronized block. 6. Prefer high-level concurrency tools like ExecutorService, ConcurrentHashMap, BlockingQueue, and CountDownLatch to reduce error risk. To avoid concurrency issues, minimize shared mutable state and rely on proven thread-safe utilities and immutable objects whenever possible.

Concurrency in Java allows multiple threads to run simultaneously, improving performance and responsiveness—especially in server-side applications. But with great power comes great complexity. When not handled properly, concurrency can introduce subtle, hard-to-debug issues. Here are the most common problems and how to solve them effectively.

1. Race Conditions and Data Inconsistency

A race condition occurs when multiple threads access shared data simultaneously, and at least one of them modifies it, leading to unpredictable results.

Example:

public class Counter {
    private int count = 0;
    public void increment() { count  ; }
    public int getCount() { return count; }
}

Calling increment() from multiple threads can result in lost updates because count is not atomic—it involves read, modify, and write steps.

Solutions:

• Use synchronized keyword:

  public synchronized void increment() { count  ; }

  This ensures only one thread can execute the method at a time.

• Use java.util.concurrent.atomic classes:

  private AtomicInteger count = new AtomicInteger(0);
  public void increment() { count.incrementAndGet(); }

  Atomic classes provide lock-free thread-safe operations.

• Use explicit locks (ReentrantLock):

  private final ReentrantLock lock = new ReentrantLock();
  public void increment() {
      lock.lock();
      try {
          count  ;
      } finally {
          lock.unlock();
      }
  }

  Offers more control than synchronized, including try-lock and fairness policies.

2. Deadlock

Deadlock happens when two or more threads are blocked forever, each waiting for a resource held by the other.

Example: Thread A holds Lock 1 and waits for Lock 2.
Thread B holds Lock 2 and waits for Lock 1 → deadlock.

How to avoid:

• Always acquire locks in a consistent order: Enforce a global ordering (e.g., always acquire Lock 1 before Lock 2).

• Use timeouts when acquiring locks:

  if (lock.tryLock(1000, TimeUnit.MILLISECONDS)) {
      try {
          // critical section
      } finally {
          lock.unlock();
      }
  } else {
      // handle timeout
  }

• Use tools like jstack to detect deadlocks during development.

3. Thread Interference and Visibility Issues

Even if operations appear atomic, the JVM and CPU optimizations (like caching in CPU registers or reordering instructions) can cause one thread not to see changes made by another.

Example:

private boolean running = true;
public void run() {
    while (running) {
        // do work
    }
}

One thread sets running = false, but another thread may never see the update due to caching.

Solution: Use volatile keyword:

private volatile boolean running = true;

volatile ensures:

• Writes to the variable are immediately visible to other threads.
• Prevents certain compiler/CPU reorderings around the variable.

For compound actions (like read-modify-write), volatile alone isn't enough—combine with synchronization or atomic classes.

4. Liveness Problems: Livelock and Starvation

• Starvation: A thread is perpetually denied access to resources. For example, low-priority threads may never get CPU time.

  • Fix: Use fair locking policies (new ReentrantLock(true)), avoid indefinite loop waits without yielding.

• Livelock: Threads are active but unable to make progress (e.g., two threads repeatedly respond to each other's actions).

  • Fix: Introduce randomness or backoff strategies. For example, retry with a random delay.

5. Improper Use of wait(), notify(), and notifyAll()

Using wait() without a loop or outside a synchronized block can cause IllegalMonitorStateException or missed signals.

Correct pattern:

synchronized (lock) {
    while (conditionNotMet) {
        lock.wait(); // Releases lock and waits
    }
    // proceed when condition is met
}

Always:

• Call wait() inside a while loop (not if) to recheck the condition after waking up.
• Ensure the lock is held before calling wait() or notify().

Alternatively, use higher-level concurrency utilities.

6. Prefer High-Level Concurrency Utilities

Instead of managing threads and locks manually, use the java.util.concurrent package:

• ExecutorService for thread management:

  ExecutorService executor = Executors.newFixedThreadPool(4);
  executor.submit(() -> doWork());

• ConcurrentHashMap, CopyOnWriteArrayList for thread-safe collections.

• BlockingQueue for producer-consumer patterns:

  BlockingQueue<Task> queue = new LinkedBlockingQueue<>();

• CountDownLatch, CyclicBarrier, Semaphore for coordination.

These are battle-tested, efficient, and reduce the chance of errors.

---

Basically, while Java gives you powerful tools for concurrency, the key is to minimize shared mutable state and lean on proven utilities instead of rolling your own synchronization. Most issues stem from assuming thread safety when it’s not guaranteed—so when in doubt, check the docs or use immutable objects and thread-safe classes.

The above is the detailed content of Solving Common Concurrency Issues in Java. For more information, please follow other related articles on the PHP Chinese website!