Java provides a robust multithreading model that allows concurrent execution of tasks.
Here’s a list of key thread concepts in Java:
1. Basics of Threads
Thread – A lightweight subprocess that runs concurrently within a program.
Process vs. Thread – A process is an independent execution unit, whereas a thread is
a subset of a process.
Creating Threads
o Extending Thread class
o Implementing Runnable interface
o Using Callable and Future
2. Thread Lifecycle
1. New – Created but not started.
2. Runnable – Ready to run, waiting for CPU time.
3. Blocked – Waiting for a resource to be released.
4. Waiting – Waiting indefinitely until notified.
5. Timed Waiting – Waiting for a specified time.
6. Terminated – Finished execution.
3. Thread Methods
start() – Starts a new thread.
run() – Defines the thread’s task.
sleep(ms) – Pauses execution for a given time.
join() – Waits for a thread to finish.
yield() – Hints that the thread scheduler can switch tasks.
interrupt() – Interrupts a sleeping or waiting thread.
isAlive() – Checks if the thread is still running.
4. Thread Synchronization
synchronized keyword – Ensures only one thread accesses a block/method at a time.
Lock interface (ReentrantLock) – More flexible locking mechanism.
wait(), notify(), notifyAll() – Thread communication methods.
volatile keyword – Ensures visibility of shared variables.
5. Thread Concurrency Utilities (java.util.concurrent)
Executor Framework (ExecutorService) – Manages thread pools.
Callable and Future – Handles asynchronous tasks with return values.
CountDownLatch, CyclicBarrier, Semaphore – Synchronization utilities.
Fork/Join Framework – Splits tasks for parallel execution.
6. Thread Safety Techniques
Immutable Objects – Prevents modification by multiple threads.
Atomic Variables (AtomicInteger, AtomicBoolean) – Provides lock-free thread safety.
ThreadLocal – Stores thread-specific data.
7. Deadlocks, Starvation & Livelocks
Deadlock – Two or more threads waiting on each other indefinitely.
Starvation – Low-priority thread never gets CPU time.
Livelock – Threads keep changing states without making progress.
8. Daemon Threads
Background threads that run in the JVM until all user threads finish (e.g., Garbage
Collector thread).
9. Thread Groups
Organizes threads into groups for collective management.
10. Thread Priorities
Threads have priority values (1 to 10) influencing scheduling.
Would you like details on any specific topic? 😊
Thread Synchronization in Java
Thread synchronization is a mechanism that ensures that multiple threads do not interfere
with each other when accessing shared resources. Java provides several ways to handle
synchronization:
1. synchronized Keyword
The synchronized keyword is used to restrict access to a block of code or a method
so that only one thread can execute it at a time.
It prevents race conditions when multiple threads try to modify shared data
simultaneously.
Example: Synchronized Method
java
CopyEdit
class Counter {
private int count = 0;
public synchronized void increment() { // Only one thread can execute
this method at a time
count++;
}
public int getCount() {
return count;
}
}
Example: Synchronized Block
java
CopyEdit
class Counter {
private int count = 0;
public void increment() {
synchronized(this) { // Lock is applied only on this block
count++;
}
}
public int getCount() {
return count;
}
}
A synchronized block is preferred over a synchronized method when we need more
fine-grained control.
2. Lock Interface (ReentrantLock)
ReentrantLock is an implementation of the Lock interface, providing more advanced
synchronization than the synchronized keyword.
It allows:
o Fairness policy (first-come-first-serve thread execution)
o Interruptible locks (a thread can be interrupted while waiting for a lock)
o Try-lock mechanism (check if the lock is available without blocking)
Example of ReentrantLock
java
CopyEdit
import java.util.concurrent.locks.ReentrantLock;
class SharedResource {
private final ReentrantLock lock = new ReentrantLock();
private int count = 0;
public void increment() {
lock.lock(); // Acquiring the lock
try {
count++;
} finally {
lock.unlock(); // Releasing the lock
}
}
public int getCount() {
return count;
}
}
Why use ReentrantLock over synchronized?
o Provides explicit lock control (lock/unlock manually)
o Supports tryLock() (check if the lock is available without waiting)
o Can be used with Condition variables for fine-grained thread control
3. wait(), notify(), and notifyAll()
These methods are used for thread communication inside synchronized blocks or methods.
wait() → Makes the thread wait until another thread calls notify()
notify() → Wakes up a single thread that is waiting
notifyAll() → Wakes up all waiting threads
Example: Producer-Consumer Problem
java
CopyEdit
class SharedQueue {
private int data;
private boolean available = false;
public synchronized void put(int value) {
while (available) { // Wait if data is already available
try { wait(); } catch (InterruptedException e)
{ e.printStackTrace(); }
}
data = value;
available = true;
notify(); // Notify waiting threads
}
public synchronized int get() {
while (!available) { // Wait if no data is available
try { wait(); } catch (InterruptedException e)
{ e.printStackTrace(); }
}
available = false;
notify(); // Notify waiting threads
return data;
}
}
Why use wait() and notify()?
o Helps in avoiding busy waiting (CPU wastage)
o Enables thread communication efficiently
4. volatile Keyword
Ensures that a shared variable's value is always read from the main memory and
not from a thread’s cache.
This guarantees visibility across multiple threads.
Example without volatile (Incorrect Behavior)
java
CopyEdit
class SharedResource {
private boolean running = true;
public void stop() {
running = false; // Other threads may not see this change
immediately
}
public void start() {
while (running) {
// Some work
}
}
}
The running variable might be cached by a thread, leading to an infinite loop even
after stop() is called.
Example with volatile (Correct Behavior)
java
CopyEdit
class SharedResource {
private volatile boolean running = true; // Ensures visibility across
threads
public void stop() {
running = false; // All threads will immediately see this update
}
public void start() {
while (running) {
// Some work
}
}
}
The volatile keyword ensures immediate visibility of changes made by one thread
to all other threads.
Conclusion
Feature Purpose
synchronized Ensures mutual exclusion (only one thread at a time)
ReentrantLock More flexible locking mechanism
wait(), notify() Thread communication mechanisms
volatile Ensures visibility of shared variables
Each method has its use case:
Use synchronized for simple mutual exclusion.
Use ReentrantLock for complex locking needs.
Use wait()/notify() for thread coordination.
Use volatile for variable visibility (but not atomicity).
Would you like an example for a specific use case? 😊
