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

Explanation

This Java code demonstrates how to implement multithreading using the Runnable interface. Multithreading allows a program to execute multiple parts of code concurrently, making it more efficient and responsive.

Here's a step-by-step breakdown of the logic:

1. MyRunnable Class Definition:

   • The MyRunnable class is defined, and it implements Runnable. The Runnable interface is a core component of Java's concurrency API, designed for objects that are intended to be executed by a thread. By implementing this interface, MyRunnable signals that it contains a task that can be run in a separate thread.
   • It contains a single method, public void run(), which is a requirement for any class implementing the Runnable interface. This run() method is where the actual code that the new thread will execute is placed.

2. run() Method Logic:

   • Inside the run() method, a for loop iterates from i = 1 to 5.
   • In each iteration, it prints a message to the console: "Thread using Runnable interface:" followed by the current value of i.
   • Immediately after printing, Thread.sleep(500); is called. This line causes the currently executing thread (in this case, the new thread created from MyRunnable) to pause its execution for 500 milliseconds (half a second).
   • The try-catch block is essential because Thread.sleep() can throw an InterruptedException. This exception occurs if another thread interrupts the current thread while it's sleeping. The catch block simply prints the exception if it occurs, preventing the program from crashing.

3. RunnableInterface Class and main Method:

   • This is the main class that contains the main method, the entry point of the Java application.
   • MyRunnable obj = new MyRunnable();: An object of the MyRunnable class is created. This obj now encapsulates the task (the run() method's logic) that we want to execute in a separate thread. It's important to note that obj itself is not a thread; it's just the task.
   • Thread tl = new Thread(obj);: A Thread object named tl is created. The constructor new Thread(Runnable target) is used here, where obj (our MyRunnable instance) is passed as the target. This links the MyRunnable task to the Thread object, telling tl what code to execute when it starts.
   • tl.start();: This is the crucial line that initiates multithreading. Calling start() on a Thread object does two main things:
     1. It allocates a new call stack for the new thread.
     2. It then invokes the run() method of the Runnable object (which was passed during thread creation) on this new call stack. It's vital to call start() and not run() directly. Calling run() directly would simply execute the run() method in the current thread (the main thread in this case), defeating the purpose of multithreading.

In essence, this code defines a task (MyRunnable) and then creates a new thread (tl) to execute that task concurrently with the main thread. Since only one new thread is created in this example, the output will show the messages from this new thread, paused at half-second intervals.

Algorithm

The algorithm used to implement multithreading with the Runnable interface in this program is as follows:

1. Define the Task: Create a class (e.g., MyRunnable) that implements the java.lang.Runnable interface.
2. Implement the run() Method: Override the public void run() method within the Runnable implementing class. This method will contain the actual code that the new thread is supposed to execute.
3. Add Thread Logic: Inside the run() method:
   • Implement a loop to perform a repetitive action (e.g., printing messages).
   • Introduce a delay using Thread.sleep(milliseconds) to simulate work or demonstrate thread pausing.
   • Wrap Thread.sleep() in a try-catch block to handle InterruptedException.
4. Create Runnable Instance: In the main method of your application's entry point class (e.g., RunnableInterface), create an object of the Runnable implementing class (e.g., MyRunnable obj = new MyRunnable();).
5. Create Thread Instance: Create a java.lang.Thread object, passing the Runnable instance created in the previous step to its constructor (e.g., Thread tl = new Thread(obj);).
6. Start the Thread: Call the start() method on the Thread object (e.g., tl.start();). This initiates the new thread's execution, which will then call the run() method of the Runnable object in a separate thread of control.