Multithreading Fundamentals

⏱ Estimated reading time: 2 min

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:

1. New: Thread object is created but not started.

2. Runnable: Thread is ready to run and waiting for CPU time.

3. Running: Thread is executing.

4. Blocked/Waiting: Thread is waiting for a resource or another thread.

5. 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

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.