Multithreading in Java

Aashi Gangrade
3 min readDec 27, 2023

--

Multithreading is a concurrent execution mechanism in Java that allows multiple threads to run concurrently within a single program. A thread is a small process that runs alongside the main program. Multithreading allows multiple tasks to be done at the same time, making the program work faster.

Creating and Managing Threads in Java:

1. Extending the Thread Class:

  • Create a class that extends the Thread class.
  • Override the run method to define the code that will be executed in the new thread.
class MyThread extends Thread {
public void run() {
// Code to be executed in the new thread
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Value " + i);
}
}
}
public class ThreadExample {
public static void main(String[] args) {
MyThread thread1 = new MyThread();
MyThread thread2 = new MyThread();
thread1.start(); // Start the first thread
thread2.start(); // Start the second thread
}
}

2. Implementing the Runnable Interface:

  • Create a class that implements the Runnable interface.
  • Implement the run method in the class.
class MyRunnable implements Runnable {
public void run() {
// Code to be executed in the new thread
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getId() + " Value " + i);
}
}
}
public class RunnableExample {
public static void main(String[] args) {
Thread thread1 = new Thread(new MyRunnable());
Thread thread2 = new Thread(new MyRunnable());
thread1.start(); // Start the first thread
thread2.start(); // Start the second thread
}
}

Thread Lifecycle:

  • New: The thread is in the new state before the start method is called.
  • Runnable: The thread moves to the runnable state after the start method is invoked, and the thread scheduler selects it to be the next to execute.
  • Blocked: A thread transitions to the blocked state when it wants to access an object that another thread has locked.
  • Waiting: A thread transitions to the waiting state when it is waiting for another thread to perform a particular action.
  • Timed Waiting: A thread is in the timed waiting state when it calls a method with a specified waiting time.
  • Terminated: A thread enters the terminated state when its run method completes.

Thread Synchronization:

When multiple threads are accessing shared resources, synchronization is necessary to avoid conflicts and ensure data consistency. This is typically achieved using the synchronized keyword or using higher-level concurrency utilities provided by the java.util.concurrent package.

class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
public synchronized int getCount() {
return count;
}
}
public class SynchronizationExample {
public static void main(String[] args) {
Counter counter = new Counter();
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
counter.increment();
}
});
thread1.start();
thread2.start();
try {
thread1.join(); // Wait for thread1 to finish
thread2.join(); // Wait for thread2 to finish
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Count: " + counter.getCount()); // Should be 20000 with proper synchronization
}
}

In this example, the increment and getCount methods are synchronized to prevent data corruption and ensure that only one thread can access them at a time. The join method is used to wait for threads to complete their execution before printing the final count.

--

--

Aashi Gangrade

Software Engineer 2 at Intuit | Backend Developer (Java + Kotlin)