A Java thread represents an execution path. Production applications generally benefit from executors that manage task scheduling and lifecycle.

Runnable task = () ->
    System.out.println(Thread.currentThread().getName());

Thread thread = new Thread(task);
thread.start();

Calling start() creates a new execution path; calling run() directly is an ordinary method call on the current thread.

Shared mutable state is where concurrency becomes difficult. Ask who owns state, who can mutate it, and what synchronization establishes visibility and ordering.

synchronized provides mutual exclusion and memory-visibility guarantees. ReentrantLock offers additional features such as timed acquisition.

private final Object lock = new Object();
private int count;

void increment() {
    synchronized (lock) {
        count++;
    }
}

int getCount() {
    synchronized (lock) {
        return count;
    }
}

A data race occurs when concurrent access includes a write without appropriate synchronization. The Java Memory Model defines happens-before relationships.

volatile provides visibility and ordering guarantees but does not make compound operations such as count++ atomic.

Executors separate task submission from thread management. CompletableFuture composes asynchronous stages.

ExecutorService pool = Executors.newFixedThreadPool(4);

CompletableFuture<String> future =
    CompletableFuture.supplyAsync(() -> loadUser(), pool)
        .thenApply(User::name);

future.thenAccept(System.out::println);

Choose executor sizes based on workload. CPU-bound and blocking I/O workloads usually need different strategies. Always define shutdown behavior for owned executors.

Java provides ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue, and atomic classes such as AtomicInteger and AtomicReference.

ConcurrentHashMap<String, LongAdder> counters =
    new ConcurrentHashMap<>();

counters.computeIfAbsent("java", key -> new LongAdder())
        .increment();

Concurrent collections provide well-defined concurrent operations. LongAdder can outperform AtomicLong under heavy contention because updates are distributed across cells.

Virtual threads are lightweight Java threads designed to make high-concurrency blocking workloads easier to express.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    Future<String> future =
        executor.submit(() -> fetchRemoteData());
    System.out.println(future.get());
}

Virtual threads do not make CPU-bound work faster. They improve scalability for workloads where many tasks spend time waiting. Concurrency still needs limits around databases, APIs, queues, and other external resources.