Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Strong Java concurrency answers start by naming the guarantee a design needs: mutual exclusion, visibility, ordering, or atomicity. These 40 questions move from core terminology to shared state and task execution. They are a practice set, not a definitive or ranked list of questions asked in every interview; the exact questions vary by role and interviewer.
Concurrency foundations
1. What is the difference between concurrency and parallelism?
Concurrency is the ability to make progress on multiple tasks during overlapping periods; their steps may be interleaved. Parallelism means tasks are actually executing at the same time, for example on separate processor cores. A concurrent program can run without parallel execution, and parallel execution is not automatically faster: coordination, contention, and the work being performed all matter.
2. Why use multiple threads?
Multiple threads can keep independent work moving while another task waits, or allow suitable work to run in parallel. They also introduce coordination requirements when tasks share state. A good design identifies the task and the intended benefit first, then weighs it against synchronization, scheduling, and debugging costs; adding threads by itself is not a performance strategy.
3. What is the difference between a task, a thread, and an executor?
A task is work to be performed, commonly represented by Runnable when it has no result or Callable when it produces one. A thread is an execution path. An executor accepts tasks and separates their submission from the mechanism that runs them. Keeping these roles distinct makes it possible to change task execution without rewriting the task itself.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minute#1 Best Overall
4. When would you use Runnable versus Callable?
Use Runnable for a task whose result is not returned through the task abstraction. Use Callable when the task computes a result or may report an exception through its contract. The distinction is useful when choosing how a caller will collect a result; it does not, by itself, decide which thread executes the task.
5. What is the difference between calling start() and calling run()?
Calling start() starts a thread so its work can execute on that thread. Calling run() as an ordinary method call executes the method on the caller’s current thread; it does not start a new thread. The Java Language Specification also defines an ordering guarantee: actions before a successful call to Thread.start() happen-before actions in the started thread.
6. What does Thread.join() do?
join() lets one thread wait for another thread to finish. The Java Language Specification states that actions in a thread happen-before another thread successfully returns from a join() on it. Joining can therefore be both a coordination point and an ordering relationship. A design should still decide what to do if waiting is interrupted or the worker does not finish promptly.
7. What does interrupting a thread mean?
Interruption is a coordination signal, not a general-purpose command that forcibly stops a thread. The receiving code must cooperate by checking or handling the signal, often by ending work or passing the request along. If a blocking operation reports interruption, code should handle or propagate that outcome deliberately rather than silently treating it as an ordinary result.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →8. What is the danger of waiting without a bound?
An unbounded wait can leave a thread stuck if the expected event never occurs, a worker stalls, or the coordination logic is faulty. It can also keep resources occupied and make shutdown difficult. Choose a waiting policy that fits the operation, and decide how the caller detects failure, handles interruption, and recovers when progress does not arrive.
9. What is a shared mutable state?
It is data that more than one thread can access and at least one thread can change. That combination is where unsynchronized access can produce races or break an invariant—for example, when separate fields must always agree. Interview answers should name the shared state and explain how the design protects its required invariant, rather than merely listing concurrency keywords.
10. What does thread-safe mean?
A thread-safe function is implemented so it can be executed by multiple concurrent threads. That describes behavior under concurrent use, not the presence of a particular keyword or lock. The implementation still has to protect relevant state and preserve its invariants; a synchronized method can still contain incorrect higher-level logic.
Shared state and Java memory semantics
11. What is a data race?
Under the Java Language Specification (JLS), a data race involves conflicting accesses to the same variable, at least one of them a write, that are not ordered by happens-before. The term is more precise than saying that two threads “touch the same object”: the access conflict and the ordering relationship matter.
12. What does synchronized guarantee?
Entering a synchronized region acquires a monitor; only one thread at a time can own that monitor. This provides mutual exclusion for code coordinated through that same monitor. It also establishes a visibility and ordering relationship: under the JLS, an unlock of a monitor happens-before a subsequent lock of that same monitor. The protected invariant should be clear in the code.
13. What is an intrinsic monitor?
Every Java object can serve as the monitor used by a synchronized statement or method. Threads coordinate when they synchronize on the same object. Synchronizing on different objects does not protect the same critical section from one another, even if the code being executed looks identical.
14. What is the difference between a synchronized instance method and a static synchronized method?
A synchronized instance method coordinates through the instance’s monitor. A static synchronized method coordinates through the monitor associated with that class. They are different monitors, so the two forms do not automatically exclude one another. Choose the monitor that corresponds to the shared state and invariant being protected.
15. What does it mean that Java monitors are reentrant?
A thread that already owns a monitor can acquire that same monitor again, such as when a synchronized method calls another synchronized method on the same object. This is reentrancy. It avoids self-blocking in that situation, but it does not eliminate deadlocks involving other monitors or prove that the protected logic is correct.
16. What does volatile do?
A volatile field participates in synchronization and provides a visibility and ordering guarantee for accesses to that field. In particular, a write to a volatile field happens-before subsequent reads of that field under the JLS. It can suit a state flag when the design needs readers to observe updates and does not require a larger operation to be indivisible.
17. What does volatile not do?
It does not make an arbitrary compound operation atomic. For example, count++ involves reading the current value, computing a new value, and writing it back. Two threads can interleave those steps, so one update can be lost even if count is volatile. Use an atomic operation, a lock, or another coordination design when the invariant requires an indivisible update.
18. How do visibility and atomicity differ?
Visibility concerns which value one thread is allowed to observe after another thread writes. Atomicity concerns whether an operation is indivisible from the perspective of other threads. A mechanism that helps with visibility does not necessarily provide atomicity for a sequence of steps; explain both guarantees separately when discussing shared state.
19. What is the Java Memory Model?
The Java Memory Model (JMM), specified in JLS Chapter 17, defines the legal observations of shared memory by threads. It does not require an implementation to run every source statement in one simple global sequence. Its rules determine which values reads may observe, so unsynchronized code can behave differently from a single-threaded reading of the source. The JLS puts it plainly: “The behavior of threads, particularly when not correctly synchronized, can be confusing and counterintuitive.”
20. What is happens-before?
Happens-before is the JMM’s way to reason about visibility and ordering. If one action happens-before another, the earlier action is ordered before the later one for the purposes defined by the memory model. Important examples in the JLS include monitor unlock followed by a later lock on the same monitor, a volatile write followed by a later read of that field, and the thread-start and successful-join relationships described above.
21. Why can an unsynchronized read see a surprising value?
Without an ordering relationship such as happens-before, the JMM does not promise the reader will observe a particular write just because that write appears earlier in source code. The reader must not rely on single-thread intuition for shared data that is accessed concurrently without correct synchronization. Identify the reads and writes, then identify the ordering mechanism that connects them.
22. Does correct synchronization make a program correct?
Not by itself. The JLS explains that correctly synchronized programs have sequentially consistent executions under the specification’s stated conditions. That property does not validate the program’s higher-level logic: a program can consistently execute the wrong algorithm, preserve the wrong invariant, or wait forever. Memory ordering and application correctness are related but distinct questions.
Locks, deadlocks, and coordination
23. When might an explicit lock be preferable to synchronized?
Start with the simplest mechanism that meets the requirement. An explicit lock may be worth considering when a concrete need—such as a particular acquisition or condition-handling policy—cannot be met by an intrinsic monitor. The exact methods and guarantees depend on the lock API and Java version; do not claim timed, interruptible, fairness, or condition semantics without checking that API’s contract.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errors24. What is a condition in thread coordination?
A condition represents a state or event that a thread needs to wait for before it can proceed, such as “work is available.” Coordination must connect the check of that condition with waiting and with the action that signals a change. Otherwise, a thread may proceed too early or wait despite the condition already being satisfied. Use a documented coordination abstraction rather than relying on timing guesses.
25. What is a deadlock?
A deadlock occurs when threads are stuck waiting on one another so that none can make progress. A common example is thread A holding lock X while waiting for Y, as thread B holds Y while waiting for X. Name the resources and the wait cycle in an interview answer; “the program hangs” alone does not explain the cause.
26. How can a lock-ordering rule help prevent deadlocks?
If code must acquire more than one lock, define a consistent global order and follow it everywhere. For example, if all paths acquire X before Y, the opposing X–Y versus Y–X cycle in the example above cannot form through those acquisitions. The rule has to cover every relevant code path; one inconsistent acquisition can reintroduce the cycle.
27. What other design choices can reduce deadlock risk?
Reduce the number of locks a task needs, avoid holding a lock while performing slow or externally controlled work, and keep lock ownership and release paths easy to audit. These are risk-reduction practices, not a proof that deadlock is impossible. Where complex lock interactions remain, identify the dependencies and analyze whether any cycle can still occur.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
28. What is a producer-consumer design?
Producers create work and consumers process it, with a coordination mechanism between them. A blocking queue is a common library abstraction for this pattern and can handle waiting for work or capacity as specified by the chosen queue. It avoids making every application reimplement that coordination with shared collections and ad hoc signalling.
29. How should you choose a blocking queue?
Choose based on the semantics the design needs: bounded or unbounded capacity, direct handoff, ordering, or delay behavior. These are distinct design choices, not interchangeable labels. Check the contract for the specific queue class in the Java API version used by the application before relying on a particular capacity, ordering, or blocking behavior.
30. When should you use a concurrent collection?
Use one when multiple threads need to access a collection and its documented concurrent behavior fits the operation. First ask what the data structure must guarantee: for example, whether the design needs a blocking producer-consumer handoff or concurrent access to collection operations. A concurrent collection does not automatically make a multi-step application invariant atomic.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Executors, futures, and thread pools
31. What does an Executor do?
An Executor accepts a task and decouples task submission from the details of how the task is carried out. The java.util.concurrent package documentation describes this abstraction as a way to separate task submission from execution policy. That separation lets calling code focus on work rather than manually deciding how each task gets a thread.
Recommended Free Tools
32. What does ExecutorService add?
ExecutorService extends the executor role with asynchronous task execution and lifecycle management, including controlled shutdown. The concurrency package overview also describes task queuing and scheduling among the facilities provided by executor services. Choose an appropriate service for the workload and manage its lifetime rather than treating submission as the whole design.
33. What does a Future represent?
A Future represents the result of an asynchronous computation. Its API provides ways to check completion and request cancellation, as well as to obtain the result according to its contract. A future gives the caller a handle for managing and collecting task work; it does not guarantee that cancellation will undo work that has already taken effect.
34. How does a thread pool work?
A thread pool lets an executor manage threads that run submitted tasks, rather than requiring the caller to create a new thread for every unit of work. The executor abstraction handles the separation between submission and execution; a service can also manage task execution and shutdown. Pools introduce policy choices about capacity and queueing, so the workload and lifecycle matter.
35. How should you size a thread pool?
There is no universal pool-size formula established by the executor overview. Start with the task’s characteristics—whether it spends time waiting, how much work it performs, and what shared resources it contends for—and the application’s resource limits. Validate the choice against the real workload and its latency and throughput goals; do not present a rule of thumb as a guaranteed optimum.
36. How do you shut down an executor service?
Treat shutdown as part of the service’s lifecycle: stop accepting or arranging new work as appropriate, allow or manage outstanding work according to the service’s documented policy, and ensure the owning component does not abandon the executor indefinitely. Check the exact shutdown methods and their behavior in the Java version in use rather than assuming that closing the caller’s scope automatically handles every task.
37. What does cancellation of a future mean?
Cancellation is a request represented through the future API, not proof that a task’s effects have been reversed. A task may already have run, may be running, or may need to cooperate with interruption or another cancellation signal. Design long-running work to observe cancellation where appropriate, and make any partial side effects safe to handle.
38. How would you choose between direct thread management and executors?
With direct thread management, the application owns more of the decisions about starting and coordinating threads. An executor moves task submission behind an abstraction; an executor service adds task and lifecycle facilities such as asynchronous execution and shutdown. Compare who should own execution policy, task results, cancellation, and cleanup instead of choosing based only on which API looks shorter.
39. What is the difference between a task queue and a blocking queue?
A task queue is part of how an execution system holds work to be run; a blocking queue is a coordination abstraction whose documented operations can wait for an item or available capacity. They can serve related roles, but queue semantics matter: capacity, ordering, handoff, and delay requirements should be chosen from the specific class contract, not assumed from the word “queue.”
Free tools Windows power users keep installed
One-click scans. No signup required.
40. How would you explain a concurrency design in an interview?
Describe the shared state and its invariant, then name the guarantee that preserves it: mutual exclusion, visibility, ordering, or atomicity. Explain how tasks are submitted and coordinated, what happens on interruption or cancellation, and how resources are shut down. If concurrency is not needed for the workload, say so; a defensible design is better than adding threads to demonstrate vocabulary.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
