To implement Java Program to implement Multithreading using thread class and runnable interface

Explanation

This Java code demonstrates a fundamental way to achieve multithreading in Java by extending the Thread class. Multithreading allows a program to execute multiple parts of its code concurrently, meaning they appear to run at the same time, improving responsiveness and efficiency for certain tasks.

Here's a step-by-step breakdown:

1. Defining a Custom Thread (MyThread class):

   • The MyThread class is created by extending the built-in java.lang.Thread class. This is the first way to create a thread in Java.
   • Inside MyThread, there's a method called run(). This method is crucial because it defines the task that the new thread will execute. When a thread starts, it looks for and executes the code inside its run() method.
   • The run() method contains a for loop that iterates from 1 to 5. In each iteration:
     • It prints a message to the console indicating the current thread and the iteration number (e.g., "Thread using Thread class: 1").
     • Thread.sleep(500) is called. This line tells the currently executing thread (in this case, our MyThread instance) to pause its execution for 500 milliseconds (half a second). This pause allows us to visibly see the separate, concurrent execution if we had multiple threads.
     • The Thread.sleep() method can throw an InterruptedException, which is a checked exception. Therefore, it must be enclosed in a try-catch block. If another thread interrupts our sleeping thread, this exception would be caught, and its details would be printed.

2. Starting the Thread (ThreadClass and main method):

   • The ThreadClass contains the main method, which is the entry point for any Java application.
   • Inside main, an object of our custom MyThread class is created: MyThread t1 = new MyThread();. At this point, t1 is just a regular Java object, not yet an active thread.
   • The line t1.start(); is the key. When start() is called, the Java Virtual Machine (JVM) performs two critical actions:
     • It allocates a new call stack for this new thread (t1).
     • It then calls the run() method of t1 on this newly created call stack. This is what actually begins the concurrent execution of the code defined in MyThread's run() method.
   • It's important to note that directly calling t1.run() would simply execute the run() method as a regular method call within the main thread, without creating a new thread of execution. start() is essential for true multithreading.

In essence, this code defines a simple task (printing numbers with a delay), wraps it in a custom Thread class, and then initiates that task on its own separate thread of execution, independent of the main thread.

Algorithm

The algorithm for implementing multithreading using the Thread class in this example is as follows:

1. Define a custom thread class: Create a new Java class (MyThread) that extends the java.lang.Thread class.
2. Override the run() method: Implement the public void run() method within the custom thread class. This method contains the specific task or code that the new thread will execute.
3. Implement thread's task: Inside the run() method, define a loop to iterate a fixed number of times (e.g., 5 times).
4. Perform an action and introduce a delay: Within each iteration of the loop, print a status message to the console and then pause the thread's execution for a specified duration (e.g., 500 milliseconds) using Thread.sleep().
5. Handle potential interruptions: Enclose the Thread.sleep() call within a try-catch block to gracefully handle InterruptedException in case the thread is interrupted while sleeping.
6. Create the main application class: Define a separate class (ThreadClass) that will contain the main method, serving as the application's entry point.
7. Instantiate the custom thread: In the main method, create an object of the custom thread class (e.g., MyThread t1 = new MyThread();).
8. Start the thread: Call the start() method on the newly created thread object (e.g., t1.start();). This initiates the new thread, causing its run() method to be executed concurrently with the main thread.