Introduction to Multithreading

7.1 Introduction to Multithreading

7.1.1 Explanation

Multithreading is one of Java’s most powerful features that allows concurrent execution of two or more parts of a program — called threads — to maximize CPU utilization. Each thread runs independently, yet shares the same memory space, enabling parallel processing and efficient resource management.

In a single-threaded environment, only one task executes at a time. In contrast, multithreading allows multiple tasks to run simultaneously, improving responsiveness, performance, and throughput.

Threads can be created by either:

1. Extending the Thread class and overriding its run() method, or
   
2. Implementing the Runnable interface and passing an instance to a Thread object.
   

The Java Virtual Machine (JVM) manages thread scheduling and execution using a Thread Scheduler based on priorities and system load.
Java’s modern concurrency model (since Java 8+) enhances traditional threads with Executors, Callable, Future, and Virtual Threads (introduced in Java 21), simplifying concurrent programming for scalable applications.

7.1.2 Code

class MyThread extends Thread {

public void run() {

for (int i = 1; i <= 5; i++) {

System.out.println(Thread.currentThread().getName() + " - Count: " + i);

try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }

}

}

}

public class ThreadExample {

public static void main(String[] args) {

MyThread t1 = new MyThread();

MyThread t2 = new MyThread();

t1.start();  // starts first thread

t2.start();  // starts second thread

System.out.println("Main thread completed.");

}

}

7.1.3 Example

Possible Output (interleaved):

Thread-0 - Count: 1

Thread-1 - Count: 1

Thread-0 - Count: 2

Thread-1 - Count: 2

...

Main thread completed.

Explanation:
Two threads (t1 and t2) execute concurrently, printing their counts asynchronously.
The sleep() method pauses each thread briefly, allowing interleaving of execution.
This demonstrates true parallel behavior controlled by the JVM’s thread scheduler.

7.1.4 Use Cases

• Running background tasks in desktop or server applications.
  
• Performing parallel data processing in analytics pipelines.
  
• Enhancing performance in I/O-bound or computation-heavy systems.
  
• Improving responsiveness in GUI or real-time applications.
  

7.1.5 Relevant Table

7.2 Runnable Interface and Thread Lifecycle

7.2.1 Explanation

The Runnable interface is a functional interface that defines a single method run(). It provides a cleaner, more flexible way to define tasks separate from the thread itself, enabling reuse with different thread pools or executor services.

When a Runnable object is passed to a Thread constructor, the run() method defines what the thread executes. This approach decouples task definition from thread control, which is considered best practice in modern Java design.

A thread in Java follows a lifecycle managed by the JVM:

1. New: Thread created but not started.
   
2. Runnable: Ready to execute, waiting for CPU time.
   
3. Running: Actively executing code.
   
4. Blocked/Waiting: Paused for resources or synchronization.
   
5. Terminated: Completed execution.
   

Developers can control this lifecycle using methods like start(), sleep(), join(), and interrupt().
Understanding thread states is essential for diagnosing concurrency bugs and optimizing performance.

7.2.2 Code

class Task implements Runnable {

public void run() {

for (int i = 0; i < 3; i++) {

System.out.println(Thread.currentThread().getName() + " executing task...");

try { Thread.sleep(400); } catch (InterruptedException e) { e.printStackTrace(); }

}

}

}

public class RunnableDemo {

public static void main(String[] args) throws InterruptedException {

Thread thread1 = new Thread(new Task(), "Worker-1");

Thread thread2 = new Thread(new Task(), "Worker-2");

thread1.start();

thread2.start();

thread1.join(); // Waits for completion

thread2.join();

System.out.println("All tasks completed.");

}

}

7.2.3 Example

Output:

Worker-1 executing task...

Worker-2 executing task...

Worker-1 executing task...

Worker-2 executing task...

All tasks completed.

Explanation:
Each worker thread runs concurrently, performing the same task.
The join() method ensures the main thread waits for both to finish, demonstrating thread coordination and synchronization in execution order.

7.2.4 Use Cases

• Defining reusable, concurrent tasks without subclassing Thread.
  
• Executing multiple independent operations simultaneously.
  
• Creating concurrent web servers or task processors.
  
• Managing workloads in parallel computing environments.
  

7.2.5 Relevant Table

7.3 Synchronization and Inter-thread Communication

7.3.1 Explanation

In multithreaded applications, multiple threads may try to access shared resources simultaneously, leading to data inconsistency or race conditions.
Java solves this problem using synchronization, which ensures that only one thread accesses a shared resource at a time.

The synchronized keyword can be applied to methods or code blocks to enforce mutual exclusion. This creates a lock on the resource, preventing others from modifying it concurrently.

Java also provides inter-thread communication mechanisms using wait(), notify(), and notifyAll(), allowing threads to coordinate execution by pausing and resuming based on conditions.
Since Java 5+, higher-level concurrency utilities like ReentrantLock, Semaphore, and CountDownLatch in java.util.concurrent offer more flexibility and control.

Synchronization must be used carefully to avoid deadlocks (when two threads wait indefinitely for each other’s locks).

7.3.2 Code

class Counter {

private int count = 0;

public synchronized void increment() {

count++;

}

public int getCount() {

return count;

}

}

public class SyncExample {

public static void main(String[] args) throws InterruptedException {

Counter counter = new Counter();

Thread t1 = new Thread(() -> {

for (int i = 0; i < 1000; i++) counter.increment();

});

Thread t2 = new Thread(() -> {

for (int i = 0; i < 1000; i++) counter.increment();

});

t1.start();

t2.start();

t1.join();

t2.join();

System.out.println("Final Count: " + counter.getCount());

}

}

7.3.3 Example

Output:

Final Count: 2000

Explanation:
Without synchronization, the result would vary due to race conditions.
By marking increment() as synchronized, only one thread at a time can modify count, ensuring data integrity.

7.3.4 Use Cases

• Banking systems (avoiding balance inconsistencies).
  

• Inventory management (preventing double updates).
  

• Logging systems (thread-safe file writes).
  

• Thread communication in real-time applications.

   

7.3.5 Relevant Table