Multithreading Fundamentals

Java 123 views Dec 01, 2025 2 min read

Multithreading is a feature in Java that allows a program to execute multiple threads concurrently, enabling parallel execution of tasks. Threads are lightweight sub-processes that share the same memory space but can run independently.

1. Key Concepts

Thread

A thread is a path of execution within a program.
Every Java program has at least one thread, called the main thread.

Multithreading

The concurrent execution of two or more threads.
Improves CPU utilization and application performance.

2. Advantages of Multithreading

Better resource utilization: Multiple tasks share CPU efficiently.
Faster execution: Independent tasks run concurrently.
Improved responsiveness: GUI applications remain responsive.
Simplified program structure for concurrent tasks.

3. Thread Life Cycle

A thread in Java can be in one of the following states:

New: Thread object is created but not started.
Runnable: Thread is ready to run and waiting for CPU time.
Running: Thread is executing.
Blocked/Waiting: Thread is waiting for a resource or another thread.
Terminated/Dead: Thread has finished execution.

4. Creating Threads in Java

There are two ways to create threads:

(a) Extending the `Thread` class

class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running");
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start();  // Starts the thread
    }
}

(b) Implementing the `Runnable` interface

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable thread running");
    }
}

public class Test {
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
    }
}

Key Points:

run() method defines the thread task.
start() method initiates the thread, calling run() internally.

5. Thread Methods

Method	Description
`start()`	Starts the thread
`run()`	Contains the code to execute
`sleep(ms)`	Pauses thread for specified milliseconds
`join()`	Waits for a thread to finish
`setPriority()`	Sets thread priority (1–10)

6. Thread Synchronization

Multiple threads may access shared resources, leading to data inconsistency.
Synchronization ensures only one thread accesses a resource at a time using the synchronized keyword.

class Counter {
    int count = 0;

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

7. Conclusion

Multithreading in Java allows concurrent execution of tasks, improving performance, responsiveness, and resource utilization. Proper use of threads, synchronization, and thread management is essential for building efficient and reliable Java applications.

Some advanced sections are available for Registered Members

← Previous

Exception Handling in Depth

Thread Synchronization in Java